Fast RTPS  Version 2.14.5
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 <array>
19 #include <cstdint>
20 
21 #include <fastrtps/types/AnnotationParameterValue.h>
22 #include <fastrtps/types/TypeIdentifier.h>
23 #include <fastrtps/types/TypeObjectHashId.h>
24 #include <fastrtps/types/TypesBase.h>
25 
26 namespace eprosima {
27 namespace fastcdr {
28 class Cdr;
29 } // namespace fastcdr
30 } // namespace eprosima
31 
32 // The types in this file shall be serialized with XCDR encoding version 2
33 namespace eprosima {
34 namespace fastrtps {
35 
36 namespace types {
37 
38 /*struct CommonStructMember final {
39  MemberId member_id;
40  StructMemberFlag member_flags;
41  TypeIdentifier member_type_id;
42  };*/
44 {
45 public:
46 
47  RTPS_DllAPI CommonStructMember();
48  RTPS_DllAPI ~CommonStructMember();
49  RTPS_DllAPI CommonStructMember(
50  const CommonStructMember& x);
51  RTPS_DllAPI CommonStructMember(
52  CommonStructMember&& x);
54  const CommonStructMember& x);
56  CommonStructMember&& x);
57 
58  RTPS_DllAPI inline void member_id(
59  const MemberId& _member_id)
60  {
61  m_member_id = _member_id;
62  }
63 
64  RTPS_DllAPI inline void member_id(
65  MemberId&& _member_id)
66  {
67  m_member_id = std::move(_member_id);
68  }
69 
70  RTPS_DllAPI inline const MemberId& member_id() const
71  {
72  return m_member_id;
73  }
74 
75  RTPS_DllAPI inline MemberId& member_id()
76  {
77  return m_member_id;
78  }
79 
80  RTPS_DllAPI inline void member_flags(
81  const StructMemberFlag& _member_flags)
82  {
83  m_member_flags = _member_flags;
84  }
85 
86  RTPS_DllAPI inline void member_flags(
87  StructMemberFlag&& _member_flags)
88  {
89  m_member_flags = std::move(_member_flags);
90  }
91 
92  RTPS_DllAPI inline const StructMemberFlag& member_flags() const
93  {
94  return m_member_flags;
95  }
96 
97  RTPS_DllAPI inline StructMemberFlag& member_flags()
98  {
99  return m_member_flags;
100  }
101 
102  RTPS_DllAPI inline void member_type_id(
103  const TypeIdentifier& _member_type_id)
104  {
105  m_member_type_id = _member_type_id;
106  }
107 
108  RTPS_DllAPI inline void member_type_id(
109  TypeIdentifier&& _member_type_id)
110  {
111  m_member_type_id = std::move(_member_type_id);
112  }
113 
114  RTPS_DllAPI inline const TypeIdentifier& member_type_id() const
115  {
116  return m_member_type_id;
117  }
118 
119  RTPS_DllAPI inline TypeIdentifier& member_type_id()
120  {
121  return m_member_type_id;
122  }
123 
124 #ifndef DOXYGEN_SHOULD_SKIP_THIS
125  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::getCdrSerializedSize()",
126  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
127  RTPS_DllAPI static size_t getCdrSerializedSize(
128  const CommonStructMember& data,
129  size_t current_alignment = 0);
130  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::serialize()",
131  "In favor of version using eprosima::fastcdr::serialize.")
132  RTPS_DllAPI void serialize(
133  eprosima::fastcdr::Cdr& cdr) const;
134  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::deserialize()",
135  "In favor of version using eprosima::fastcdr::deserialize.")
136  RTPS_DllAPI void deserialize(
137  eprosima::fastcdr::Cdr& cdr);
138 #endif // DOXYGEN_SHOULD_SKIP_THIS
139 
140  RTPS_DllAPI bool operator ==(
141  const CommonStructMember& other) const;
142 
143  RTPS_DllAPI bool consistent(
144  const CommonStructMember& x,
145  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
146 
147 private:
148 
149  MemberId m_member_id;
150  StructMemberFlag m_member_flags;
151  TypeIdentifier m_member_type_id;
152 };
153 
154 // COMPLETE Details for a member of an aggregate type
155 /*struct CompleteMemberDetail final{
156  MemberName name;
157  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
158  AppliedAnnotationSeq ann_custom; // Optional
159  };*/
161 {
162 public:
163 
164  RTPS_DllAPI CompleteMemberDetail();
165  RTPS_DllAPI ~CompleteMemberDetail();
166  RTPS_DllAPI CompleteMemberDetail(
167  const CompleteMemberDetail& x);
168  RTPS_DllAPI CompleteMemberDetail(
171  const CompleteMemberDetail& x);
174 
175  RTPS_DllAPI inline void name(
176  const MemberName& _name)
177  {
178  m_name = _name;
179  }
180 
181  RTPS_DllAPI inline void name(
182  MemberName&& _name)
183  {
184  m_name = std::move(_name);
185  }
186 
187  RTPS_DllAPI inline const MemberName& name() const
188  {
189  return m_name;
190  }
191 
192  RTPS_DllAPI inline MemberName& name()
193  {
194  return m_name;
195  }
196 
197  RTPS_DllAPI inline void ann_builtin(
198  const AppliedBuiltinMemberAnnotations& _ann_builtin)
199  {
200  m_ann_builtin = _ann_builtin;
201  }
202 
203  RTPS_DllAPI inline void ann_builtin(
204  AppliedBuiltinMemberAnnotations&& _ann_builtin)
205  {
206  m_ann_builtin = std::move(_ann_builtin);
207  }
208 
209  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
210  {
211  return m_ann_builtin;
212  }
213 
215  {
216  return m_ann_builtin;
217  }
218 
219  RTPS_DllAPI inline void ann_custom(
220  const AppliedAnnotationSeq& _ann_custom)
221  {
222  m_ann_custom = _ann_custom;
223  }
224 
225  RTPS_DllAPI inline void ann_custom(
226  AppliedAnnotationSeq&& _ann_custom)
227  {
228  m_ann_custom = std::move(_ann_custom);
229  }
230 
231  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
232  {
233  return m_ann_custom;
234  }
235 
236  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
237  {
238  return m_ann_custom;
239  }
240 
241 #ifndef DOXYGEN_SHOULD_SKIP_THIS
242  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::getCdrSerializedSize()",
243  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
244  RTPS_DllAPI static size_t getCdrSerializedSize(
245  const CompleteMemberDetail& data,
246  size_t current_alignment = 0);
247  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::serialize()",
248  "In favor of version using eprosima::fastcdr::serialize.")
249  RTPS_DllAPI void serialize(
250  eprosima::fastcdr::Cdr& cdr) const;
251  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::deserialize()",
252  "In favor of version using eprosima::fastcdr::deserialize.")
253  RTPS_DllAPI void deserialize(
254  eprosima::fastcdr::Cdr& cdr);
255 #endif // DOXYGEN_SHOULD_SKIP_THIS
256 
257  RTPS_DllAPI bool operator ==(
258  const CompleteMemberDetail& other) const;
259 
260  RTPS_DllAPI bool consistent(
261  const CompleteMemberDetail& x,
262  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
263 
264 private:
265 
266  MemberName m_name;
267  AppliedBuiltinMemberAnnotations m_ann_builtin;
268  AppliedAnnotationSeq m_ann_custom;
269 };
270 
271 // MINIMAL Details for a member of an aggregate type
272 /*struct MinimalMemberDetail final{
273  NameHash name_hash;
274  };*/
275 
277 {
278 public:
279 
280  RTPS_DllAPI MinimalMemberDetail();
281  RTPS_DllAPI ~MinimalMemberDetail();
282  RTPS_DllAPI MinimalMemberDetail(
283  const MinimalMemberDetail& x);
284  RTPS_DllAPI MinimalMemberDetail(
285  MinimalMemberDetail&& x);
287  const MinimalMemberDetail& x);
289  MinimalMemberDetail&& x);
290 
291  RTPS_DllAPI inline void name_hash(
292  const NameHash& _name_hash)
293  {
294  m_name_hash = _name_hash;
295  }
296 
297  RTPS_DllAPI inline void name_hash(
298  NameHash&& _name_hash)
299  {
300  m_name_hash = std::move(_name_hash);
301  }
302 
303  RTPS_DllAPI inline const NameHash& name_hash() const
304  {
305  return m_name_hash;
306  }
307 
308  RTPS_DllAPI inline NameHash& name_hash()
309  {
310  return m_name_hash;
311  }
312 
313 #ifndef DOXYGEN_SHOULD_SKIP_THIS
314  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::getCdrSerializedSize()",
315  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
316  RTPS_DllAPI static size_t getCdrSerializedSize(
317  const MinimalMemberDetail& data,
318  size_t current_alignment = 0);
319  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::serialize()",
320  "In favor of version using eprosima::fastcdr::serialize.")
321  RTPS_DllAPI void serialize(
322  eprosima::fastcdr::Cdr& cdr) const;
323  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::deserialize()",
324  "In favor of version using eprosima::fastcdr::deserialize.")
325  RTPS_DllAPI void deserialize(
326  eprosima::fastcdr::Cdr& cdr);
327 #endif // DOXYGEN_SHOULD_SKIP_THIS
328 
329  RTPS_DllAPI bool operator ==(
330  const MinimalMemberDetail& other) const;
331 
332  RTPS_DllAPI bool consistent(
333  const MinimalMemberDetail& x,
334  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
335 
336 private:
337 
338  NameHash m_name_hash;
339 };
340 
341 // Member of an aggregate type
342 /*struct CompleteStructMember {
343  CommonStructMember common;
344  CompleteMemberDetail detail;
345  };*/
347 {
348 public:
349 
350  RTPS_DllAPI CompleteStructMember();
351  RTPS_DllAPI ~CompleteStructMember();
352  RTPS_DllAPI CompleteStructMember(
353  const CompleteStructMember& x);
354  RTPS_DllAPI CompleteStructMember(
357  const CompleteStructMember& x);
360 
361  RTPS_DllAPI inline void common(
362  const CommonStructMember& _common)
363  {
364  m_common = _common;
365  }
366 
367  RTPS_DllAPI inline void common(
368  CommonStructMember&& _common)
369  {
370  m_common = std::move(_common);
371  }
372 
373  RTPS_DllAPI inline const CommonStructMember& common() const
374  {
375  return m_common;
376  }
377 
378  RTPS_DllAPI inline CommonStructMember& common()
379  {
380  return m_common;
381  }
382 
383  RTPS_DllAPI inline void detail(
384  const CompleteMemberDetail& _detail)
385  {
386  m_detail = _detail;
387  }
388 
389  RTPS_DllAPI inline void detail(
390  CompleteMemberDetail&& _detail)
391  {
392  m_detail = std::move(_detail);
393  }
394 
395  RTPS_DllAPI inline const CompleteMemberDetail& detail() const
396  {
397  return m_detail;
398  }
399 
400  RTPS_DllAPI inline CompleteMemberDetail& detail()
401  {
402  return m_detail;
403  }
404 
405 #ifndef DOXYGEN_SHOULD_SKIP_THIS
406  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::getCdrSerializedSize()",
407  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
408  RTPS_DllAPI static size_t getCdrSerializedSize(
409  const CompleteStructMember& data,
410  size_t current_alignment = 0);
411  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::serialize()",
412  "In favor of version using eprosima::fastcdr::serialize.")
413  RTPS_DllAPI void serialize(
414  eprosima::fastcdr::Cdr& cdr) const;
415  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::deserialize()",
416  "In favor of version using eprosima::fastcdr::deserialize.")
417  RTPS_DllAPI void deserialize(
418  eprosima::fastcdr::Cdr& cdr);
419 #endif // DOXYGEN_SHOULD_SKIP_THIS
420 
421  RTPS_DllAPI bool operator ==(
422  const CompleteStructMember& other) const;
423 
424  RTPS_DllAPI bool consistent(
425  const CompleteStructMember& x,
426  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
427 
428 private:
429 
430  CommonStructMember m_common;
431  CompleteMemberDetail m_detail;
432 };
433 
434 // Ordered by the member_index
435 typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
436 
437 // Member of an aggregate type
438 /*struct MinimalStructMember {
439  CommonStructMember common;
440  MinimalMemberDetail detail;
441  };*/
443 {
444 public:
445 
446  RTPS_DllAPI MinimalStructMember();
447  RTPS_DllAPI ~MinimalStructMember();
448  RTPS_DllAPI MinimalStructMember(
449  const MinimalStructMember& x);
450  RTPS_DllAPI MinimalStructMember(
451  MinimalStructMember&& x);
453  const MinimalStructMember& x);
455  MinimalStructMember&& x);
456 
457  RTPS_DllAPI inline void common(
458  const CommonStructMember& _common)
459  {
460  m_common = _common;
461  }
462 
463  RTPS_DllAPI inline void common(
464  CommonStructMember&& _common)
465  {
466  m_common = std::move(_common);
467  }
468 
469  RTPS_DllAPI inline const CommonStructMember& common() const
470  {
471  return m_common;
472  }
473 
474  RTPS_DllAPI inline CommonStructMember& common()
475  {
476  return m_common;
477  }
478 
479  RTPS_DllAPI inline void detail(
480  const MinimalMemberDetail& _detail)
481  {
482  m_detail = _detail;
483  }
484 
485  RTPS_DllAPI inline void detail(
486  MinimalMemberDetail&& _detail)
487  {
488  m_detail = std::move(_detail);
489  }
490 
491  RTPS_DllAPI inline const MinimalMemberDetail& detail() const
492  {
493  return m_detail;
494  }
495 
496  RTPS_DllAPI inline MinimalMemberDetail& detail()
497  {
498  return m_detail;
499  }
500 
501 #ifndef DOXYGEN_SHOULD_SKIP_THIS
502  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::getCdrSerializedSize()",
503  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
504  RTPS_DllAPI static size_t getCdrSerializedSize(
505  const MinimalStructMember& data,
506  size_t current_alignment = 0);
507  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::serialize()",
508  "In favor of version using eprosima::fastcdr::serialize.")
509  RTPS_DllAPI void serialize(
510  eprosima::fastcdr::Cdr& cdr) const;
511  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::deserialize()",
512  "In favor of version using eprosima::fastcdr::deserialize.")
513  RTPS_DllAPI void deserialize(
514  eprosima::fastcdr::Cdr& cdr);
515 #endif // DOXYGEN_SHOULD_SKIP_THIS
516 
517  RTPS_DllAPI bool operator ==(
518  const MinimalStructMember& other) const;
519 
520  RTPS_DllAPI bool consistent(
521  const MinimalStructMember& x,
522  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
523 
524 private:
525 
526  CommonStructMember m_common;
527  MinimalMemberDetail m_detail;
528 };
529 
530 // Ordered by common.member_id
531 typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
532 
533 /*struct AppliedBuiltinTypeAnnotations {
534  AppliedVerbatimAnnotation verbatim; // verbatim(...) // optional
535  };*/
537 {
538 public:
539 
550 
551  RTPS_DllAPI inline void verbatim(
552  const AppliedVerbatimAnnotation& _verbatim)
553  {
554  m_verbatim = _verbatim;
555  }
556 
557  RTPS_DllAPI inline void verbatim(
558  AppliedVerbatimAnnotation&& _verbatim)
559  {
560  m_verbatim = std::move(_verbatim);
561  }
562 
563  RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const
564  {
565  return m_verbatim;
566  }
567 
568  RTPS_DllAPI inline AppliedVerbatimAnnotation& verbatim()
569  {
570  return m_verbatim;
571  }
572 
573 #ifndef DOXYGEN_SHOULD_SKIP_THIS
574  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::getCdrSerializedSize()",
575  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
576  RTPS_DllAPI static size_t getCdrSerializedSize(
577  const AppliedBuiltinTypeAnnotations& data,
578  size_t current_alignment = 0);
579  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::serialize()",
580  "In favor of version using eprosima::fastcdr::serialize.")
581  RTPS_DllAPI void serialize(
582  eprosima::fastcdr::Cdr& cdr) const;
583  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::deserialize()",
584  "In favor of version using eprosima::fastcdr::deserialize.")
585  RTPS_DllAPI void deserialize(
586  eprosima::fastcdr::Cdr& cdr);
587 #endif // DOXYGEN_SHOULD_SKIP_THIS
588 
589  RTPS_DllAPI bool operator ==(
590  const AppliedBuiltinTypeAnnotations& other) const;
591 
592  RTPS_DllAPI bool consistent(
594  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
595 
596 private:
597 
598  AppliedVerbatimAnnotation m_verbatim;
599 };
600 
601 /*struct MinimalTypeDetail final{
602  // Empty. Available for future extension
603  };*/
605 {
606 public:
607 
608  RTPS_DllAPI MinimalTypeDetail();
609  RTPS_DllAPI ~MinimalTypeDetail();
610  RTPS_DllAPI MinimalTypeDetail(
611  const MinimalTypeDetail& x);
612  RTPS_DllAPI MinimalTypeDetail(
613  MinimalTypeDetail&& x);
615  const MinimalTypeDetail& x);
617  MinimalTypeDetail&& x);
618 
619 #ifndef DOXYGEN_SHOULD_SKIP_THIS
620  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::getCdrSerializedSize()",
621  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
622  RTPS_DllAPI static size_t getCdrSerializedSize(
623  const MinimalTypeDetail& data,
624  size_t current_alignment = 0);
625  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::serialize()",
626  "In favor of version using eprosima::fastcdr::serialize.")
627  RTPS_DllAPI void serialize(
628  eprosima::fastcdr::Cdr& cdr) const;
629  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::deserialize()",
630  "In favor of version using eprosima::fastcdr::deserialize.")
631  RTPS_DllAPI void deserialize(
632  eprosima::fastcdr::Cdr& cdr);
633 #endif // DOXYGEN_SHOULD_SKIP_THIS
634 
635  RTPS_DllAPI bool operator ==(
636  const MinimalTypeDetail&) const
637  {
638  return true;
639  }
640 
641  RTPS_DllAPI bool consistent(
642  const MinimalTypeDetail& x,
643  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
644 
645 private:
646 
647 };
648 
649 /*struct CompleteTypeDetail final{
650  AppliedBuiltinTypeAnnotations ann_builtin; // optional
651  AppliedAnnotationSeq ann_custom; // optional
652  QualifiedTypeName type_name;
653  };*/
655 {
656 public:
657 
658  RTPS_DllAPI CompleteTypeDetail();
659  RTPS_DllAPI ~CompleteTypeDetail();
660  RTPS_DllAPI CompleteTypeDetail(
661  const CompleteTypeDetail& x);
662  RTPS_DllAPI CompleteTypeDetail(
663  CompleteTypeDetail&& x);
665  const CompleteTypeDetail& x);
667  CompleteTypeDetail&& x);
668 
669  RTPS_DllAPI inline void ann_builtin(
670  const AppliedBuiltinTypeAnnotations& _ann_builtin)
671  {
672  m_ann_builtin = _ann_builtin;
673  }
674 
675  RTPS_DllAPI inline void ann_builtin(
676  AppliedBuiltinTypeAnnotations&& _ann_builtin)
677  {
678  m_ann_builtin = std::move(_ann_builtin);
679  }
680 
681  RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const
682  {
683  return m_ann_builtin;
684  }
685 
687  {
688  return m_ann_builtin;
689  }
690 
691  RTPS_DllAPI inline void ann_custom(
692  const AppliedAnnotationSeq& _ann_custom)
693  {
694  m_ann_custom = _ann_custom;
695  }
696 
697  RTPS_DllAPI inline void ann_custom(
698  AppliedAnnotationSeq&& _ann_custom)
699  {
700  m_ann_custom = std::move(_ann_custom);
701  }
702 
703  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
704  {
705  return m_ann_custom;
706  }
707 
708  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
709  {
710  return m_ann_custom;
711  }
712 
713  RTPS_DllAPI inline void type_name(
714  const QualifiedTypeName& _type_name)
715  {
716  m_type_name = _type_name;
717  }
718 
719  RTPS_DllAPI inline void type_name(
720  QualifiedTypeName&& _type_name)
721  {
722  m_type_name = std::move(_type_name);
723  }
724 
725  RTPS_DllAPI inline const QualifiedTypeName& type_name() const
726  {
727  return m_type_name;
728  }
729 
730  RTPS_DllAPI inline QualifiedTypeName& type_name()
731  {
732  return m_type_name;
733  }
734 
735 #ifndef DOXYGEN_SHOULD_SKIP_THIS
736  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::getCdrSerializedSize()",
737  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
738  RTPS_DllAPI static size_t getCdrSerializedSize(
739  const CompleteTypeDetail& data,
740  size_t current_alignment = 0);
741  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::serialize()",
742  "In favor of version using eprosima::fastcdr::serialize.")
743  RTPS_DllAPI void serialize(
744  eprosima::fastcdr::Cdr& cdr) const;
745  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::deserialize()",
746  "In favor of version using eprosima::fastcdr::deserialize.")
747  RTPS_DllAPI void deserialize(
748  eprosima::fastcdr::Cdr& cdr);
749 #endif // DOXYGEN_SHOULD_SKIP_THIS
750 
751  RTPS_DllAPI bool operator ==(
752  const CompleteTypeDetail& other) const;
753 
754  RTPS_DllAPI bool consistent(
755  const CompleteTypeDetail& x,
756  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
757 
758 private:
759 
760  AppliedBuiltinTypeAnnotations m_ann_builtin;
761  AppliedAnnotationSeq m_ann_custom;
762  QualifiedTypeName m_type_name;
763 };
764 /*struct CompleteStructHeader {
765  TypeIdentifier base_type;
766  CompleteTypeDetail detail;
767  };*/
769 {
770 public:
771 
772  RTPS_DllAPI CompleteStructHeader();
773  RTPS_DllAPI ~CompleteStructHeader();
774  RTPS_DllAPI CompleteStructHeader(
775  const CompleteStructHeader& x);
776  RTPS_DllAPI CompleteStructHeader(
779  const CompleteStructHeader& x);
782 
783  RTPS_DllAPI inline void base_type(
784  const TypeIdentifier& _base_type)
785  {
786  m_base_type = _base_type;
787  }
788 
789  RTPS_DllAPI inline void base_type(
790  TypeIdentifier&& _base_type)
791  {
792  m_base_type = std::move(_base_type);
793  }
794 
795  RTPS_DllAPI inline const TypeIdentifier& base_type() const
796  {
797  return m_base_type;
798  }
799 
800  RTPS_DllAPI inline TypeIdentifier& base_type()
801  {
802  return m_base_type;
803  }
804 
805  RTPS_DllAPI inline void detail(
806  const CompleteTypeDetail& _detail)
807  {
808  m_detail = _detail;
809  }
810 
811  RTPS_DllAPI inline void detail(
812  CompleteTypeDetail&& _detail)
813  {
814  m_detail = std::move(_detail);
815  }
816 
817  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
818  {
819  return m_detail;
820  }
821 
822  RTPS_DllAPI inline CompleteTypeDetail& detail()
823  {
824  return m_detail;
825  }
826 
827 #ifndef DOXYGEN_SHOULD_SKIP_THIS
828  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::getCdrSerializedSize()",
829  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
830  RTPS_DllAPI static size_t getCdrSerializedSize(
831  const CompleteStructHeader& data,
832  size_t current_alignment = 0);
833  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::serialize()",
834  "In favor of version using eprosima::fastcdr::serialize.")
835  RTPS_DllAPI void serialize(
836  eprosima::fastcdr::Cdr& cdr) const;
837  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::deserialize()",
838  "In favor of version using eprosima::fastcdr::deserialize.")
839  RTPS_DllAPI void deserialize(
840  eprosima::fastcdr::Cdr& cdr);
841 #endif // DOXYGEN_SHOULD_SKIP_THIS
842 
843  RTPS_DllAPI bool operator ==(
844  const CompleteStructHeader& other) const;
845 
846  RTPS_DllAPI bool consistent(
847  const CompleteStructHeader& x,
848  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
849 
850 private:
851 
852  TypeIdentifier m_base_type;
853  CompleteTypeDetail m_detail;
854 };
855 /*struct MinimalStructHeader {
856  TypeIdentifier base_type;
857  MinimalTypeDetail detail;
858  };*/
860 {
861 public:
862 
863  RTPS_DllAPI MinimalStructHeader();
864  RTPS_DllAPI ~MinimalStructHeader();
865  RTPS_DllAPI MinimalStructHeader(
866  const MinimalStructHeader& x);
867  RTPS_DllAPI MinimalStructHeader(
868  MinimalStructHeader&& x);
870  const MinimalStructHeader& x);
872  MinimalStructHeader&& x);
873 
874  RTPS_DllAPI inline void base_type(
875  const TypeIdentifier& _base_type)
876  {
877  m_base_type = _base_type;
878  }
879 
880  RTPS_DllAPI inline void base_type(
881  TypeIdentifier&& _base_type)
882  {
883  m_base_type = std::move(_base_type);
884  }
885 
886  RTPS_DllAPI inline const TypeIdentifier& base_type() const
887  {
888  return m_base_type;
889  }
890 
891  RTPS_DllAPI inline TypeIdentifier& base_type()
892  {
893  return m_base_type;
894  }
895 
896  RTPS_DllAPI inline void detail(
897  const MinimalTypeDetail& _detail)
898  {
899  m_detail = _detail;
900  }
901 
902  RTPS_DllAPI inline void detail(
903  MinimalTypeDetail&& _detail)
904  {
905  m_detail = std::move(_detail);
906  }
907 
908  RTPS_DllAPI inline const MinimalTypeDetail& detail() const
909  {
910  return m_detail;
911  }
912 
913  RTPS_DllAPI inline MinimalTypeDetail& detail()
914  {
915  return m_detail;
916  }
917 
918 #ifndef DOXYGEN_SHOULD_SKIP_THIS
919  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::getCdrSerializedSize()",
920  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
921  RTPS_DllAPI static size_t getCdrSerializedSize(
922  const MinimalStructHeader& data,
923  size_t current_alignment = 0);
924  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::serialize()",
925  "In favor of version using eprosima::fastcdr::serialize.")
926  RTPS_DllAPI void serialize(
927  eprosima::fastcdr::Cdr& cdr) const;
928  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::deserialize()",
929  "In favor of version using eprosima::fastcdr::deserialize.")
930  RTPS_DllAPI void deserialize(
931  eprosima::fastcdr::Cdr& cdr);
932 #endif // DOXYGEN_SHOULD_SKIP_THIS
933 
934  RTPS_DllAPI bool operator ==(
935  const MinimalStructHeader& other) const;
936 
937  RTPS_DllAPI bool consistent(
938  const MinimalStructHeader& x,
939  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
940 
941 private:
942 
943  TypeIdentifier m_base_type;
944  MinimalTypeDetail m_detail;
945 };
946 
947 /*struct CompleteStructType final{
948  StructTypeFlag struct_flags;
949  CompleteStructHeader header;
950  CompleteStructMemberSeq member_seq;
951  };*/
953 {
954 public:
955 
956  RTPS_DllAPI CompleteStructType();
957  RTPS_DllAPI ~CompleteStructType();
958  RTPS_DllAPI CompleteStructType(
959  const CompleteStructType& x);
960  RTPS_DllAPI CompleteStructType(
961  CompleteStructType&& x);
963  const CompleteStructType& x);
965  CompleteStructType&& x);
966 
967  RTPS_DllAPI inline void struct_flags(
968  const StructTypeFlag& _struct_flags)
969  {
970  m_struct_flags = _struct_flags;
971  }
972 
973  RTPS_DllAPI inline void struct_flags(
974  StructTypeFlag&& _struct_flags)
975  {
976  m_struct_flags = std::move(_struct_flags);
977  }
978 
979  RTPS_DllAPI inline const StructTypeFlag& struct_flags() const
980  {
981  return m_struct_flags;
982  }
983 
984  RTPS_DllAPI inline StructTypeFlag& struct_flags()
985  {
986  return m_struct_flags;
987  }
988 
989  RTPS_DllAPI inline void header(
990  const CompleteStructHeader& _header)
991  {
992  m_header = _header;
993  }
994 
995  RTPS_DllAPI inline void header(
996  CompleteStructHeader&& _header)
997  {
998  m_header = std::move(_header);
999  }
1000 
1001  RTPS_DllAPI inline const CompleteStructHeader& header() const
1002  {
1003  return m_header;
1004  }
1005 
1006  RTPS_DllAPI inline CompleteStructHeader& header()
1007  {
1008  return m_header;
1009  }
1010 
1011  RTPS_DllAPI inline void member_seq(
1012  const CompleteStructMemberSeq& _member_seq)
1013  {
1014  m_member_seq = _member_seq;
1015  }
1016 
1017  RTPS_DllAPI inline void member_seq(
1018  CompleteStructMemberSeq&& _member_seq)
1019  {
1020  m_member_seq = std::move(_member_seq);
1021  }
1022 
1023  RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const
1024  {
1025  return m_member_seq;
1026  }
1027 
1028  RTPS_DllAPI inline CompleteStructMemberSeq& member_seq()
1029  {
1030  return m_member_seq;
1031  }
1032 
1033 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1034  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::getCdrSerializedSize()",
1035  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1036  RTPS_DllAPI static size_t getCdrSerializedSize(
1037  const CompleteStructType& data,
1038  size_t current_alignment = 0);
1039  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::serialize()",
1040  "In favor of version using eprosima::fastcdr::serialize.")
1041  RTPS_DllAPI void serialize(
1042  eprosima::fastcdr::Cdr& cdr) const;
1043  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::deserialize()",
1044  "In favor of version using eprosima::fastcdr::deserialize.")
1045  RTPS_DllAPI void deserialize(
1046  eprosima::fastcdr::Cdr& cdr);
1047 #endif // DOXYGEN_SHOULD_SKIP_THIS
1048 
1049  RTPS_DllAPI bool operator ==(
1050  const CompleteStructType& other) const;
1051 
1052  RTPS_DllAPI bool consistent(
1053  const CompleteStructType& x,
1054  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1055 
1056 private:
1057 
1058  StructTypeFlag m_struct_flags;
1059  CompleteStructHeader m_header;
1060  CompleteStructMemberSeq m_member_seq;
1061 };
1062 
1063 /*struct MinimalStructType final{
1064  StructTypeFlag struct_flags;
1065  MinimalStructHeader header;
1066  MinimalStructMemberSeq member_seq;
1067  };*/
1069 {
1070 public:
1071 
1072  RTPS_DllAPI MinimalStructType();
1073  RTPS_DllAPI ~MinimalStructType();
1074  RTPS_DllAPI MinimalStructType(
1075  const MinimalStructType& x);
1076  RTPS_DllAPI MinimalStructType(
1077  MinimalStructType&& x);
1079  const MinimalStructType& x);
1081  MinimalStructType&& x);
1082 
1083  RTPS_DllAPI inline void struct_flags(
1084  const StructTypeFlag& _struct_flags)
1085  {
1086  m_struct_flags = _struct_flags;
1087  }
1088 
1089  RTPS_DllAPI inline void struct_flags(
1090  StructTypeFlag&& _struct_flags)
1091  {
1092  m_struct_flags = std::move(_struct_flags);
1093  }
1094 
1095  RTPS_DllAPI inline const StructTypeFlag& struct_flags() const
1096  {
1097  return m_struct_flags;
1098  }
1099 
1100  RTPS_DllAPI inline StructTypeFlag& struct_flags()
1101  {
1102  return m_struct_flags;
1103  }
1104 
1105  RTPS_DllAPI inline void header(
1106  const MinimalStructHeader& _header)
1107  {
1108  m_header = _header;
1109  }
1110 
1111  RTPS_DllAPI inline void header(
1112  MinimalStructHeader&& _header)
1113  {
1114  m_header = std::move(_header);
1115  }
1116 
1117  RTPS_DllAPI inline const MinimalStructHeader& header() const
1118  {
1119  return m_header;
1120  }
1121 
1122  RTPS_DllAPI inline MinimalStructHeader& header()
1123  {
1124  return m_header;
1125  }
1126 
1127  RTPS_DllAPI inline void member_seq(
1128  const MinimalStructMemberSeq& _member_seq)
1129  {
1130  m_member_seq = _member_seq;
1131  }
1132 
1133  RTPS_DllAPI inline void member_seq(
1134  MinimalStructMemberSeq&& _member_seq)
1135  {
1136  m_member_seq = std::move(_member_seq);
1137  }
1138 
1139  RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const
1140  {
1141  return m_member_seq;
1142  }
1143 
1144  RTPS_DllAPI inline MinimalStructMemberSeq& member_seq()
1145  {
1146  return m_member_seq;
1147  }
1148 
1149 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1150  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::getCdrSerializedSize()",
1151  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1152  RTPS_DllAPI static size_t getCdrSerializedSize(
1153  const MinimalStructType& data,
1154  size_t current_alignment = 0);
1155  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::serialize()",
1156  "In favor of version using eprosima::fastcdr::serialize.")
1157  RTPS_DllAPI void serialize(
1158  eprosima::fastcdr::Cdr& cdr) const;
1159  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::deserialize()",
1160  "In favor of version using eprosima::fastcdr::deserialize.")
1161  RTPS_DllAPI void deserialize(
1162  eprosima::fastcdr::Cdr& cdr);
1163 #endif // DOXYGEN_SHOULD_SKIP_THIS
1164 
1165  RTPS_DllAPI bool operator ==(
1166  const MinimalStructType& other) const;
1167 
1168  RTPS_DllAPI bool consistent(
1169  const MinimalStructType& x,
1170  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1171 
1172 private:
1173 
1174  StructTypeFlag m_struct_flags;
1175  MinimalStructHeader m_header;
1176  MinimalStructMemberSeq m_member_seq;
1177 };
1178 
1179 // --- Union: ---------------------------------------------------------
1180 
1181 // Case labels that apply to a member of a union type
1182 // Ordered by their values
1183 typedef std::vector<int32_t> UnionCaseLabelSeq;
1184 
1185 /*struct CommonUnionMember final{
1186  MemberId member_id;
1187  UnionMemberFlag member_flags;
1188  TypeIdentifier type_id;
1189  UnionCaseLabelSeq label_seq;
1190  };*/
1192 {
1193 public:
1194 
1195  RTPS_DllAPI CommonUnionMember();
1196  RTPS_DllAPI ~CommonUnionMember();
1197  RTPS_DllAPI CommonUnionMember(
1198  const CommonUnionMember& x);
1199  RTPS_DllAPI CommonUnionMember(
1200  CommonUnionMember&& x);
1202  const CommonUnionMember& x);
1204  CommonUnionMember&& x);
1205 
1206  RTPS_DllAPI inline void member_id(
1207  const MemberId& _member_id)
1208  {
1209  m_member_id = _member_id;
1210  }
1211 
1212  RTPS_DllAPI inline void member_id(
1213  MemberId&& _member_id)
1214  {
1215  m_member_id = std::move(_member_id);
1216  }
1217 
1218  RTPS_DllAPI inline const MemberId& member_id() const
1219  {
1220  return m_member_id;
1221  }
1222 
1223  RTPS_DllAPI inline MemberId& member_id()
1224  {
1225  return m_member_id;
1226  }
1227 
1228  RTPS_DllAPI inline void member_flags(
1229  const UnionMemberFlag& _member_flags)
1230  {
1231  m_member_flags = _member_flags;
1232  }
1233 
1234  RTPS_DllAPI inline void member_flags(
1235  UnionMemberFlag&& _member_flags)
1236  {
1237  m_member_flags = std::move(_member_flags);
1238  }
1239 
1240  RTPS_DllAPI inline const UnionMemberFlag& member_flags() const
1241  {
1242  return m_member_flags;
1243  }
1244 
1245  RTPS_DllAPI inline UnionMemberFlag& member_flags()
1246  {
1247  return m_member_flags;
1248  }
1249 
1250  RTPS_DllAPI inline void type_id(
1251  const TypeIdentifier& _type_id)
1252  {
1253  m_type_id = _type_id;
1254  }
1255 
1256  RTPS_DllAPI inline void type_id(
1257  TypeIdentifier&& _type_id)
1258  {
1259  m_type_id = std::move(_type_id);
1260  }
1261 
1262  RTPS_DllAPI inline const TypeIdentifier& type_id() const
1263  {
1264  return m_type_id;
1265  }
1266 
1267  RTPS_DllAPI inline TypeIdentifier& type_id()
1268  {
1269  return m_type_id;
1270  }
1271 
1272  RTPS_DllAPI inline void label_seq(
1273  const UnionCaseLabelSeq& _label_seq)
1274  {
1275  m_label_seq = _label_seq;
1276  }
1277 
1278  RTPS_DllAPI inline void label_seq(
1279  UnionCaseLabelSeq&& _label_seq)
1280  {
1281  m_label_seq = std::move(_label_seq);
1282  }
1283 
1284  RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const
1285  {
1286  return m_label_seq;
1287  }
1288 
1289  RTPS_DllAPI inline UnionCaseLabelSeq& label_seq()
1290  {
1291  return m_label_seq;
1292  }
1293 
1294 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1295  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::getCdrSerializedSize()",
1296  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1297  RTPS_DllAPI static size_t getCdrSerializedSize(
1298  const CommonUnionMember& data,
1299  size_t current_alignment = 0);
1300  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::serialize()",
1301  "In favor of version using eprosima::fastcdr::serialize.")
1302  RTPS_DllAPI void serialize(
1303  eprosima::fastcdr::Cdr& cdr) const;
1304  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::deserialize()",
1305  "In favor of version using eprosima::fastcdr::deserialize.")
1306  RTPS_DllAPI void deserialize(
1307  eprosima::fastcdr::Cdr& cdr);
1308 #endif // DOXYGEN_SHOULD_SKIP_THIS
1309 
1310  RTPS_DllAPI bool operator ==(
1311  const CommonUnionMember& other) const;
1312 
1313  RTPS_DllAPI bool consistent(
1314  const CommonUnionMember& x,
1315  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1316 
1317 private:
1318 
1319  MemberId m_member_id;
1320  UnionMemberFlag m_member_flags;
1321  TypeIdentifier m_type_id;
1322  UnionCaseLabelSeq m_label_seq;
1323 };
1324 
1325 // Member of a union type
1326 /*struct CompleteUnionMember {
1327  CommonUnionMember common;
1328  CompleteMemberDetail detail;
1329  };*/
1331 {
1332 public:
1333 
1334  RTPS_DllAPI CompleteUnionMember();
1335  RTPS_DllAPI ~CompleteUnionMember();
1336  RTPS_DllAPI CompleteUnionMember(
1337  const CompleteUnionMember& x);
1338  RTPS_DllAPI CompleteUnionMember(
1339  CompleteUnionMember&& x);
1341  const CompleteUnionMember& x);
1343  CompleteUnionMember&& x);
1344 
1345  RTPS_DllAPI inline void common(
1346  const CommonUnionMember& _common)
1347  {
1348  m_common = _common;
1349  }
1350 
1351  RTPS_DllAPI inline void common(
1352  CommonUnionMember&& _common)
1353  {
1354  m_common = std::move(_common);
1355  }
1356 
1357  RTPS_DllAPI inline const CommonUnionMember& common() const
1358  {
1359  return m_common;
1360  }
1361 
1362  RTPS_DllAPI inline CommonUnionMember& common()
1363  {
1364  return m_common;
1365  }
1366 
1367  RTPS_DllAPI inline void detail(
1368  const CompleteMemberDetail& _detail)
1369  {
1370  m_detail = _detail;
1371  }
1372 
1373  RTPS_DllAPI inline void detail(
1374  CompleteMemberDetail&& _detail)
1375  {
1376  m_detail = std::move(_detail);
1377  }
1378 
1379  RTPS_DllAPI inline const CompleteMemberDetail& detail() const
1380  {
1381  return m_detail;
1382  }
1383 
1384  RTPS_DllAPI inline CompleteMemberDetail& detail()
1385  {
1386  return m_detail;
1387  }
1388 
1389 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1390  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::getCdrSerializedSize()",
1391  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1392  RTPS_DllAPI static size_t getCdrSerializedSize(
1393  const CompleteUnionMember& data,
1394  size_t current_alignment = 0);
1395  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::serialize()",
1396  "In favor of version using eprosima::fastcdr::serialize.")
1397  RTPS_DllAPI void serialize(
1398  eprosima::fastcdr::Cdr& cdr) const;
1399  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::deserialize()",
1400  "In favor of version using eprosima::fastcdr::deserialize.")
1401  RTPS_DllAPI void deserialize(
1402  eprosima::fastcdr::Cdr& cdr);
1403 #endif // DOXYGEN_SHOULD_SKIP_THIS
1404 
1405  RTPS_DllAPI bool operator ==(
1406  const CompleteUnionMember& other) const;
1407 
1408  RTPS_DllAPI bool consistent(
1409  const CompleteUnionMember& x,
1410  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1411 
1412 private:
1413 
1414  CommonUnionMember m_common;
1415  CompleteMemberDetail m_detail;
1416 };
1417 
1418 // Ordered by member_index
1419 typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
1420 
1421 // Member of a union type
1422 /*struct MinimalUnionMember {
1423  CommonUnionMember common;
1424  MinimalMemberDetail detail;
1425  };*/
1427 {
1428 public:
1429 
1430  RTPS_DllAPI MinimalUnionMember();
1431  RTPS_DllAPI ~MinimalUnionMember();
1432  RTPS_DllAPI MinimalUnionMember(
1433  const MinimalUnionMember& x);
1434  RTPS_DllAPI MinimalUnionMember(
1435  MinimalUnionMember&& x);
1437  const MinimalUnionMember& x);
1439  MinimalUnionMember&& x);
1440 
1441  RTPS_DllAPI inline void common(
1442  const CommonUnionMember& _common)
1443  {
1444  m_common = _common;
1445  }
1446 
1447  RTPS_DllAPI inline void common(
1448  CommonUnionMember&& _common)
1449  {
1450  m_common = std::move(_common);
1451  }
1452 
1453  RTPS_DllAPI inline const CommonUnionMember& common() const
1454  {
1455  return m_common;
1456  }
1457 
1458  RTPS_DllAPI inline CommonUnionMember& common()
1459  {
1460  return m_common;
1461  }
1462 
1463  RTPS_DllAPI inline void detail(
1464  const MinimalMemberDetail& _detail)
1465  {
1466  m_detail = _detail;
1467  }
1468 
1469  RTPS_DllAPI inline void detail(
1470  MinimalMemberDetail&& _detail)
1471  {
1472  m_detail = std::move(_detail);
1473  }
1474 
1475  RTPS_DllAPI inline const MinimalMemberDetail& detail() const
1476  {
1477  return m_detail;
1478  }
1479 
1480  RTPS_DllAPI inline MinimalMemberDetail& detail()
1481  {
1482  return m_detail;
1483  }
1484 
1485 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1486  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::getCdrSerializedSize()",
1487  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1488  RTPS_DllAPI static size_t getCdrSerializedSize(
1489  const MinimalUnionMember& data,
1490  size_t current_alignment = 0);
1491  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::serialize()",
1492  "In favor of version using eprosima::fastcdr::serialize.")
1493  RTPS_DllAPI void serialize(
1494  eprosima::fastcdr::Cdr& cdr) const;
1495  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::deserialize()",
1496  "In favor of version using eprosima::fastcdr::deserialize.")
1497  RTPS_DllAPI void deserialize(
1498  eprosima::fastcdr::Cdr& cdr);
1499 #endif // DOXYGEN_SHOULD_SKIP_THIS
1500 
1501  RTPS_DllAPI bool operator ==(
1502  const MinimalUnionMember& other) const;
1503 
1504  RTPS_DllAPI bool consistent(
1505  const MinimalUnionMember& x,
1506  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1507 
1508 private:
1509 
1510  CommonUnionMember m_common;
1511  MinimalMemberDetail m_detail;
1512 };
1513 
1514 // Ordered by MinimalUnionMember.common.member_id
1515 typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
1516 
1517 /*struct CommonDiscriminatorMember final{
1518  UnionDiscriminatorFlag member_flags;
1519  TypeIdentifier type_id;
1520  };*/
1522 {
1523 public:
1524 
1528  const CommonDiscriminatorMember& x);
1532  const CommonDiscriminatorMember& x);
1535 
1536  RTPS_DllAPI inline void member_flags(
1537  const UnionDiscriminatorFlag& _member_flags)
1538  {
1539  m_member_flags = _member_flags;
1540  }
1541 
1542  RTPS_DllAPI inline void member_flags(
1543  UnionDiscriminatorFlag&& _member_flags)
1544  {
1545  m_member_flags = std::move(_member_flags);
1546  }
1547 
1548  RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const
1549  {
1550  return m_member_flags;
1551  }
1552 
1553  RTPS_DllAPI inline UnionDiscriminatorFlag& member_flags()
1554  {
1555  return m_member_flags;
1556  }
1557 
1558  RTPS_DllAPI inline void type_id(
1559  const TypeIdentifier& _type_id)
1560  {
1561  m_type_id = _type_id;
1562  }
1563 
1564  RTPS_DllAPI inline void type_id(
1565  TypeIdentifier&& _type_id)
1566  {
1567  m_type_id = std::move(_type_id);
1568  }
1569 
1570  RTPS_DllAPI inline const TypeIdentifier& type_id() const
1571  {
1572  return m_type_id;
1573  }
1574 
1575  RTPS_DllAPI inline TypeIdentifier& type_id()
1576  {
1577  return m_type_id;
1578  }
1579 
1580 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1581  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::getCdrSerializedSize()",
1582  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1583  RTPS_DllAPI static size_t getCdrSerializedSize(
1584  const CommonDiscriminatorMember& data,
1585  size_t current_alignment = 0);
1586  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::serialize()",
1587  "In favor of version using eprosima::fastcdr::serialize.")
1588  RTPS_DllAPI void serialize(
1589  eprosima::fastcdr::Cdr& cdr) const;
1590  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::deserialize()",
1591  "In favor of version using eprosima::fastcdr::deserialize.")
1592  RTPS_DllAPI void deserialize(
1593  eprosima::fastcdr::Cdr& cdr);
1594 #endif // DOXYGEN_SHOULD_SKIP_THIS
1595 
1596  RTPS_DllAPI bool operator ==(
1597  const CommonDiscriminatorMember& other) const;
1598 
1599  RTPS_DllAPI bool consistent(
1600  const CommonDiscriminatorMember& x,
1601  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1602 
1603 private:
1604 
1605  UnionDiscriminatorFlag m_member_flags;
1606  TypeIdentifier m_type_id;
1607 };
1608 
1609 // Member of a union type
1610 /*struct CompleteDiscriminatorMember {
1611  CommonDiscriminatorMember common;
1612  AppliedBuiltinTypeAnnotations ann_builtin; // Optional
1613  AppliedAnnotationSeq ann_custom; // Optional
1614  };*/
1616 {
1617 public:
1618 
1622  const CompleteDiscriminatorMember& x);
1626  const CompleteDiscriminatorMember& x);
1629 
1630  RTPS_DllAPI inline void common(
1631  const CommonDiscriminatorMember& _common)
1632  {
1633  m_common = _common;
1634  }
1635 
1636  RTPS_DllAPI inline void common(
1637  CommonDiscriminatorMember&& _common)
1638  {
1639  m_common = std::move(_common);
1640  }
1641 
1642  RTPS_DllAPI inline const CommonDiscriminatorMember& common() const
1643  {
1644  return m_common;
1645  }
1646 
1647  RTPS_DllAPI inline CommonDiscriminatorMember& common()
1648  {
1649  return m_common;
1650  }
1651 
1652  RTPS_DllAPI inline void ann_builtin(
1653  const AppliedBuiltinTypeAnnotations& _ann_builtin)
1654  {
1655  m_ann_builtin = _ann_builtin;
1656  }
1657 
1658  RTPS_DllAPI inline void ann_builtin(
1659  AppliedBuiltinTypeAnnotations&& _ann_builtin)
1660  {
1661  m_ann_builtin = std::move(_ann_builtin);
1662  }
1663 
1664  RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const
1665  {
1666  return m_ann_builtin;
1667  }
1668 
1670  {
1671  return m_ann_builtin;
1672  }
1673 
1674  RTPS_DllAPI inline void ann_custom(
1675  const AppliedAnnotationSeq& _ann_custom)
1676  {
1677  m_ann_custom = _ann_custom;
1678  }
1679 
1680  RTPS_DllAPI inline void ann_custom(
1681  AppliedAnnotationSeq&& _ann_custom)
1682  {
1683  m_ann_custom = std::move(_ann_custom);
1684  }
1685 
1686  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
1687  {
1688  return m_ann_custom;
1689  }
1690 
1691  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
1692  {
1693  return m_ann_custom;
1694  }
1695 
1696 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1697  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::getCdrSerializedSize()",
1698  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1699  RTPS_DllAPI static size_t getCdrSerializedSize(
1700  const CompleteDiscriminatorMember& data,
1701  size_t current_alignment = 0);
1702  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::serialize()",
1703  "In favor of version using eprosima::fastcdr::serialize.")
1704  RTPS_DllAPI void serialize(
1705  eprosima::fastcdr::Cdr& cdr) const;
1706  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::deserialize()",
1707  "In favor of version using eprosima::fastcdr::deserialize.")
1708  RTPS_DllAPI void deserialize(
1709  eprosima::fastcdr::Cdr& cdr);
1710 #endif // DOXYGEN_SHOULD_SKIP_THIS
1711 
1712  RTPS_DllAPI bool operator ==(
1713  const CompleteDiscriminatorMember& other) const;
1714 
1715  RTPS_DllAPI bool consistent(
1716  const CompleteDiscriminatorMember& x,
1717  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1718 
1719 private:
1720 
1721  CommonDiscriminatorMember m_common;
1722  AppliedBuiltinTypeAnnotations m_ann_builtin;
1723  AppliedAnnotationSeq m_ann_custom;
1724 };
1725 
1726 // Member of a union type
1727 /*struct MinimalDiscriminatorMember {
1728  CommonDiscriminatorMember common;
1729  };*/
1731 {
1732 public:
1733 
1737  const MinimalDiscriminatorMember& x);
1741  const MinimalDiscriminatorMember& x);
1744 
1745  RTPS_DllAPI inline void common(
1746  const CommonDiscriminatorMember& _common)
1747  {
1748  m_common = _common;
1749  }
1750 
1751  RTPS_DllAPI inline void common(
1752  CommonDiscriminatorMember&& _common)
1753  {
1754  m_common = std::move(_common);
1755  }
1756 
1757  RTPS_DllAPI inline const CommonDiscriminatorMember& common() const
1758  {
1759  return m_common;
1760  }
1761 
1762  RTPS_DllAPI inline CommonDiscriminatorMember& common()
1763  {
1764  return m_common;
1765  }
1766 
1767 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1768  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::getCdrSerializedSize()",
1769  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1770  RTPS_DllAPI static size_t getCdrSerializedSize(
1771  const MinimalDiscriminatorMember& data,
1772  size_t current_alignment = 0);
1773  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::serialize()",
1774  "In favor of version using eprosima::fastcdr::serialize.")
1775  RTPS_DllAPI void serialize(
1776  eprosima::fastcdr::Cdr& cdr) const;
1777  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::deserialize()",
1778  "In favor of version using eprosima::fastcdr::deserialize.")
1779  RTPS_DllAPI void deserialize(
1780  eprosima::fastcdr::Cdr& cdr);
1781 #endif // DOXYGEN_SHOULD_SKIP_THIS
1782 
1783  RTPS_DllAPI bool operator ==(
1784  const MinimalDiscriminatorMember& other) const;
1785 
1786  RTPS_DllAPI bool consistent(
1787  const MinimalDiscriminatorMember& x,
1788  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1789 
1790 private:
1791 
1792  CommonDiscriminatorMember m_common;
1793 };
1794 
1795 /*struct CompleteUnionHeader {
1796  CompleteTypeDetail detail;
1797  };*/
1799 {
1800 public:
1801 
1802  RTPS_DllAPI CompleteUnionHeader();
1803  RTPS_DllAPI ~CompleteUnionHeader();
1804  RTPS_DllAPI CompleteUnionHeader(
1805  const CompleteUnionHeader& x);
1806  RTPS_DllAPI CompleteUnionHeader(
1807  CompleteUnionHeader&& x);
1809  const CompleteUnionHeader& x);
1811  CompleteUnionHeader&& x);
1812 
1813  RTPS_DllAPI inline void detail(
1814  const CompleteTypeDetail& _detail)
1815  {
1816  m_detail = _detail;
1817  }
1818 
1819  RTPS_DllAPI inline void detail(
1820  CompleteTypeDetail&& _detail)
1821  {
1822  m_detail = std::move(_detail);
1823  }
1824 
1825  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
1826  {
1827  return m_detail;
1828  }
1829 
1830  RTPS_DllAPI inline CompleteTypeDetail& detail()
1831  {
1832  return m_detail;
1833  }
1834 
1835 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1836  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::getCdrSerializedSize()",
1837  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1838  RTPS_DllAPI static size_t getCdrSerializedSize(
1839  const CompleteUnionHeader& data,
1840  size_t current_alignment = 0);
1841  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::serialize()",
1842  "In favor of version using eprosima::fastcdr::serialize.")
1843  RTPS_DllAPI void serialize(
1844  eprosima::fastcdr::Cdr& cdr) const;
1845  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::deserialize()",
1846  "In favor of version using eprosima::fastcdr::deserialize.")
1847  RTPS_DllAPI void deserialize(
1848  eprosima::fastcdr::Cdr& cdr);
1849 #endif // DOXYGEN_SHOULD_SKIP_THIS
1850 
1851  RTPS_DllAPI bool operator ==(
1852  const CompleteUnionHeader& other) const;
1853 
1854  RTPS_DllAPI bool consistent(
1855  const CompleteUnionHeader& x,
1856  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1857 
1858 private:
1859 
1860  CompleteTypeDetail m_detail;
1861 };
1862 
1863 /*struct MinimalUnionHeader {
1864  MinimalTypeDetail detail;
1865  };*/
1867 {
1868 public:
1869 
1870  RTPS_DllAPI MinimalUnionHeader();
1871  RTPS_DllAPI ~MinimalUnionHeader();
1872  RTPS_DllAPI MinimalUnionHeader(
1873  const MinimalUnionHeader& x);
1874  RTPS_DllAPI MinimalUnionHeader(
1875  MinimalUnionHeader&& x);
1877  const MinimalUnionHeader& x);
1879  MinimalUnionHeader&& x);
1880 
1881  RTPS_DllAPI inline void detail(
1882  const MinimalTypeDetail& _detail)
1883  {
1884  m_detail = _detail;
1885  }
1886 
1887  RTPS_DllAPI inline void detail(
1888  MinimalTypeDetail&& _detail)
1889  {
1890  m_detail = std::move(_detail);
1891  }
1892 
1893  RTPS_DllAPI inline const MinimalTypeDetail& detail() const
1894  {
1895  return m_detail;
1896  }
1897 
1898  RTPS_DllAPI inline MinimalTypeDetail& detail()
1899  {
1900  return m_detail;
1901  }
1902 
1903 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1904  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::getCdrSerializedSize()",
1905  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1906  RTPS_DllAPI static size_t getCdrSerializedSize(
1907  const MinimalUnionHeader& data,
1908  size_t current_alignment = 0);
1909  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::serialize()",
1910  "In favor of version using eprosima::fastcdr::serialize.")
1911  RTPS_DllAPI void serialize(
1912  eprosima::fastcdr::Cdr& cdr) const;
1913  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::deserialize()",
1914  "In favor of version using eprosima::fastcdr::deserialize.")
1915  RTPS_DllAPI void deserialize(
1916  eprosima::fastcdr::Cdr& cdr);
1917 #endif // DOXYGEN_SHOULD_SKIP_THIS
1918 
1919  RTPS_DllAPI bool operator ==(
1920  const MinimalUnionHeader& other) const;
1921 
1922  RTPS_DllAPI bool consistent(
1923  const MinimalUnionHeader& x,
1924  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1925 
1926 private:
1927 
1928  MinimalTypeDetail m_detail;
1929 };
1930 
1931 /*struct CompleteUnionType final{
1932  UnionTypeFlag union_flags;
1933  CompleteUnionHeader header;
1934  CompleteDiscriminatorMember discriminator;
1935  CompleteUnionMemberSeq member_seq;
1936  };*/
1938 {
1939 public:
1940 
1941  RTPS_DllAPI CompleteUnionType();
1942  RTPS_DllAPI ~CompleteUnionType();
1943  RTPS_DllAPI CompleteUnionType(
1944  const CompleteUnionType& x);
1945  RTPS_DllAPI CompleteUnionType(
1946  CompleteUnionType&& x);
1948  const CompleteUnionType& x);
1950  CompleteUnionType&& x);
1951 
1952  RTPS_DllAPI inline void union_flags(
1953  const UnionTypeFlag& _union_flags)
1954  {
1955  m_union_flags = _union_flags;
1956  }
1957 
1958  RTPS_DllAPI inline void union_flags(
1959  UnionTypeFlag&& _union_flags)
1960  {
1961  m_union_flags = std::move(_union_flags);
1962  }
1963 
1964  RTPS_DllAPI inline const UnionTypeFlag& union_flags() const
1965  {
1966  return m_union_flags;
1967  }
1968 
1969  RTPS_DllAPI inline UnionTypeFlag& union_flags()
1970  {
1971  return m_union_flags;
1972  }
1973 
1974  RTPS_DllAPI inline void header(
1975  const CompleteUnionHeader& _header)
1976  {
1977  m_header = _header;
1978  }
1979 
1980  RTPS_DllAPI inline void header(
1981  CompleteUnionHeader&& _header)
1982  {
1983  m_header = std::move(_header);
1984  }
1985 
1986  RTPS_DllAPI inline const CompleteUnionHeader& header() const
1987  {
1988  return m_header;
1989  }
1990 
1991  RTPS_DllAPI inline CompleteUnionHeader& header()
1992  {
1993  return m_header;
1994  }
1995 
1996  RTPS_DllAPI inline void discriminator(
1997  const CompleteDiscriminatorMember& _discriminator)
1998  {
1999  m_discriminator = _discriminator;
2000  }
2001 
2002  RTPS_DllAPI inline void discriminator(
2003  CompleteDiscriminatorMember&& _discriminator)
2004  {
2005  m_discriminator = std::move(_discriminator);
2006  }
2007 
2008  RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const
2009  {
2010  return m_discriminator;
2011  }
2012 
2014  {
2015  return m_discriminator;
2016  }
2017 
2018  RTPS_DllAPI inline void member_seq(
2019  const CompleteUnionMemberSeq& _member_seq)
2020  {
2021  m_member_seq = _member_seq;
2022  }
2023 
2024  RTPS_DllAPI inline void member_seq(
2025  CompleteUnionMemberSeq&& _member_seq)
2026  {
2027  m_member_seq = std::move(_member_seq);
2028  }
2029 
2030  RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const
2031  {
2032  return m_member_seq;
2033  }
2034 
2035  RTPS_DllAPI inline CompleteUnionMemberSeq& member_seq()
2036  {
2037  return m_member_seq;
2038  }
2039 
2040 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2041  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::getCdrSerializedSize()",
2042  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2043  RTPS_DllAPI static size_t getCdrSerializedSize(
2044  const CompleteUnionType& data,
2045  size_t current_alignment = 0);
2046  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::serialize()",
2047  "In favor of version using eprosima::fastcdr::serialize.")
2048  RTPS_DllAPI void serialize(
2049  eprosima::fastcdr::Cdr& cdr) const;
2050  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::deserialize()",
2051  "In favor of version using eprosima::fastcdr::deserialize.")
2052  RTPS_DllAPI void deserialize(
2053  eprosima::fastcdr::Cdr& cdr);
2054 #endif // DOXYGEN_SHOULD_SKIP_THIS
2055 
2056  RTPS_DllAPI bool operator ==(
2057  const CompleteUnionType& other) const;
2058 
2059  RTPS_DllAPI bool consistent(
2060  const CompleteUnionType& x,
2061  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2062 
2063 private:
2064 
2065  UnionTypeFlag m_union_flags;
2066  CompleteUnionHeader m_header;
2067  CompleteDiscriminatorMember m_discriminator;
2068  CompleteUnionMemberSeq m_member_seq;
2069 };
2070 
2071 /*struct MinimalUnionType final{
2072  UnionTypeFlag union_flags;
2073  MinimalUnionHeader header;
2074  MinimalDiscriminatorMember discriminator;
2075  MinimalUnionMemberSeq member_seq;
2076  };*/
2078 {
2079 public:
2080 
2081  RTPS_DllAPI MinimalUnionType();
2082  RTPS_DllAPI ~MinimalUnionType();
2083  RTPS_DllAPI MinimalUnionType(
2084  const MinimalUnionType& x);
2085  RTPS_DllAPI MinimalUnionType(
2086  MinimalUnionType&& x);
2088  const MinimalUnionType& x);
2090  MinimalUnionType&& x);
2091 
2092  RTPS_DllAPI inline void union_flags(
2093  const UnionTypeFlag& _union_flags)
2094  {
2095  m_union_flags = _union_flags;
2096  }
2097 
2098  RTPS_DllAPI inline void union_flags(
2099  UnionTypeFlag&& _union_flags)
2100  {
2101  m_union_flags = std::move(_union_flags);
2102  }
2103 
2104  RTPS_DllAPI inline const UnionTypeFlag& union_flags() const
2105  {
2106  return m_union_flags;
2107  }
2108 
2109  RTPS_DllAPI inline UnionTypeFlag& union_flags()
2110  {
2111  return m_union_flags;
2112  }
2113 
2114  RTPS_DllAPI inline void header(
2115  const MinimalUnionHeader& _header)
2116  {
2117  m_header = _header;
2118  }
2119 
2120  RTPS_DllAPI inline void header(
2121  MinimalUnionHeader&& _header)
2122  {
2123  m_header = std::move(_header);
2124  }
2125 
2126  RTPS_DllAPI inline const MinimalUnionHeader& header() const
2127  {
2128  return m_header;
2129  }
2130 
2131  RTPS_DllAPI inline MinimalUnionHeader& header()
2132  {
2133  return m_header;
2134  }
2135 
2136  RTPS_DllAPI inline void discriminator(
2137  const MinimalDiscriminatorMember& _discriminator)
2138  {
2139  m_discriminator = _discriminator;
2140  }
2141 
2142  RTPS_DllAPI inline void discriminator(
2143  MinimalDiscriminatorMember&& _discriminator)
2144  {
2145  m_discriminator = std::move(_discriminator);
2146  }
2147 
2148  RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const
2149  {
2150  return m_discriminator;
2151  }
2152 
2154  {
2155  return m_discriminator;
2156  }
2157 
2158  RTPS_DllAPI inline void member_seq(
2159  const MinimalUnionMemberSeq& _member_seq)
2160  {
2161  m_member_seq = _member_seq;
2162  }
2163 
2164  RTPS_DllAPI inline void member_seq(
2165  MinimalUnionMemberSeq&& _member_seq)
2166  {
2167  m_member_seq = std::move(_member_seq);
2168  }
2169 
2170  RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const
2171  {
2172  return m_member_seq;
2173  }
2174 
2175  RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq()
2176  {
2177  return m_member_seq;
2178  }
2179 
2180 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2181  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::getCdrSerializedSize()",
2182  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2183  RTPS_DllAPI static size_t getCdrSerializedSize(
2184  const MinimalUnionType& data,
2185  size_t current_alignment = 0);
2186  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::serialize()",
2187  "In favor of version using eprosima::fastcdr::serialize.")
2188  RTPS_DllAPI void serialize(
2189  eprosima::fastcdr::Cdr& cdr) const;
2190  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::deserialize()",
2191  "In favor of version using eprosima::fastcdr::deserialize.")
2192  RTPS_DllAPI void deserialize(
2193  eprosima::fastcdr::Cdr& cdr);
2194 #endif // DOXYGEN_SHOULD_SKIP_THIS
2195 
2196  RTPS_DllAPI bool operator ==(
2197  const MinimalUnionType& other) const;
2198 
2199  RTPS_DllAPI bool consistent(
2200  const MinimalUnionType& x,
2201  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2202 
2203 private:
2204 
2205  UnionTypeFlag m_union_flags;
2206  MinimalUnionHeader m_header;
2207  MinimalDiscriminatorMember m_discriminator;
2208  MinimalUnionMemberSeq m_member_seq;
2209 };
2210 
2211 // --- Annotation: ---------------------------------------------------
2212 /*struct CommonAnnotationParameter final{
2213  AnnotationParameterFlag member_flags;
2214  TypeIdentifier member_type_id;
2215  };*/
2217 {
2218 public:
2219 
2223  const CommonAnnotationParameter& x);
2227  const CommonAnnotationParameter& x);
2230 
2231  RTPS_DllAPI inline void member_flags(
2232  const AnnotationParameterFlag& _member_flags)
2233  {
2234  m_member_flags = _member_flags;
2235  }
2236 
2237  RTPS_DllAPI inline void member_flags(
2238  AnnotationParameterFlag&& _member_flags)
2239  {
2240  m_member_flags = std::move(_member_flags);
2241  }
2242 
2243  RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const
2244  {
2245  return m_member_flags;
2246  }
2247 
2249  {
2250  return m_member_flags;
2251  }
2252 
2253  RTPS_DllAPI inline void member_type_id(
2254  const TypeIdentifier& _member_type_id)
2255  {
2256  m_member_type_id = _member_type_id;
2257  }
2258 
2259  RTPS_DllAPI inline void member_type_id(
2260  TypeIdentifier&& _member_type_id)
2261  {
2262  m_member_type_id = std::move(_member_type_id);
2263  }
2264 
2265  RTPS_DllAPI inline const TypeIdentifier& member_type_id() const
2266  {
2267  return m_member_type_id;
2268  }
2269 
2270  RTPS_DllAPI inline TypeIdentifier& member_type_id()
2271  {
2272  return m_member_type_id;
2273  }
2274 
2275 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2276  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::getCdrSerializedSize()",
2277  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2278  RTPS_DllAPI static size_t getCdrSerializedSize(
2279  const CommonAnnotationParameter& data,
2280  size_t current_alignment = 0);
2281  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::serialize()",
2282  "In favor of version using eprosima::fastcdr::serialize.")
2283  RTPS_DllAPI void serialize(
2284  eprosima::fastcdr::Cdr& cdr) const;
2285  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::deserialize()",
2286  "In favor of version using eprosima::fastcdr::deserialize.")
2287  RTPS_DllAPI void deserialize(
2288  eprosima::fastcdr::Cdr& cdr);
2289 #endif // DOXYGEN_SHOULD_SKIP_THIS
2290 
2291  RTPS_DllAPI bool operator ==(
2292  const CommonAnnotationParameter& other) const;
2293 
2294  RTPS_DllAPI bool consistent(
2295  const CommonAnnotationParameter& x,
2296  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2297 
2298 private:
2299 
2300  AnnotationParameterFlag m_member_flags;
2301  TypeIdentifier m_member_type_id;
2302 };
2303 
2304 // Member of an annotation type
2305 
2306 /*struct CompleteAnnotationParameter {
2307  CommonAnnotationParameter common;
2308  MemberName name;
2309  AnnotationParameterValue default_value;
2310  };*/
2312 {
2313 public:
2314 
2318  const CompleteAnnotationParameter& x);
2322  const CompleteAnnotationParameter& x);
2325 
2326  RTPS_DllAPI inline void common(
2327  const CommonAnnotationParameter& _common)
2328  {
2329  m_common = _common;
2330  }
2331 
2332  RTPS_DllAPI inline void common(
2333  CommonAnnotationParameter&& _common)
2334  {
2335  m_common = std::move(_common);
2336  }
2337 
2338  RTPS_DllAPI inline const CommonAnnotationParameter& common() const
2339  {
2340  return m_common;
2341  }
2342 
2343  RTPS_DllAPI inline CommonAnnotationParameter& common()
2344  {
2345  return m_common;
2346  }
2347 
2348  RTPS_DllAPI inline void name(
2349  const MemberName& _name)
2350  {
2351  m_name = _name;
2352  }
2353 
2354  RTPS_DllAPI inline void name(
2355  MemberName&& _name)
2356  {
2357  m_name = std::move(_name);
2358  }
2359 
2360  RTPS_DllAPI inline const MemberName& name() const
2361  {
2362  return m_name;
2363  }
2364 
2365  RTPS_DllAPI inline MemberName& name()
2366  {
2367  return m_name;
2368  }
2369 
2370  RTPS_DllAPI inline void default_value(
2371  const AnnotationParameterValue& _default_value)
2372  {
2373  m_default_value = _default_value;
2374  }
2375 
2376  RTPS_DllAPI inline void default_value(
2377  AnnotationParameterValue&& _default_value)
2378  {
2379  m_default_value = std::move(_default_value);
2380  }
2381 
2382  RTPS_DllAPI inline const AnnotationParameterValue& default_value() const
2383  {
2384  return m_default_value;
2385  }
2386 
2388  {
2389  return m_default_value;
2390  }
2391 
2392 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2393  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::getCdrSerializedSize()",
2394  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2395  RTPS_DllAPI static size_t getCdrSerializedSize(
2396  const CompleteAnnotationParameter& data,
2397  size_t current_alignment = 0);
2398  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::serialize()",
2399  "In favor of version using eprosima::fastcdr::serialize.")
2400  RTPS_DllAPI void serialize(
2401  eprosima::fastcdr::Cdr& cdr) const;
2402  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::deserialize()",
2403  "In favor of version using eprosima::fastcdr::deserialize.")
2404  RTPS_DllAPI void deserialize(
2405  eprosima::fastcdr::Cdr& cdr);
2406 #endif // DOXYGEN_SHOULD_SKIP_THIS
2407 
2408  RTPS_DllAPI bool operator ==(
2409  const CompleteAnnotationParameter& other) const;
2410 
2411  RTPS_DllAPI bool consistent(
2412  const CompleteAnnotationParameter& x,
2413  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2414 
2415 private:
2416 
2417  CommonAnnotationParameter m_common;
2418  MemberName m_name;
2419  AnnotationParameterValue m_default_value;
2420 };
2421 // Ordered by CompleteAnnotationParameter.name
2422 typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
2423 /*struct MinimalAnnotationParameter {
2424  CommonAnnotationParameter common;
2425  NameHash name_hash;
2426  AnnotationParameterValue default_value;
2427  };*/
2429 {
2430 public:
2431 
2435  const MinimalAnnotationParameter& x);
2439  const MinimalAnnotationParameter& x);
2442 
2443  RTPS_DllAPI inline void common(
2444  const CommonAnnotationParameter& _common)
2445  {
2446  m_common = _common;
2447  }
2448 
2449  RTPS_DllAPI inline void common(
2450  CommonAnnotationParameter&& _common)
2451  {
2452  m_common = std::move(_common);
2453  }
2454 
2455  RTPS_DllAPI inline const CommonAnnotationParameter& common() const
2456  {
2457  return m_common;
2458  }
2459 
2460  RTPS_DllAPI inline CommonAnnotationParameter& common()
2461  {
2462  return m_common;
2463  }
2464 
2465  RTPS_DllAPI inline void name(
2466  const MemberName& _name)
2467  {
2468  m_name = _name;
2469  }
2470 
2471  RTPS_DllAPI inline void name(
2472  MemberName&& _name)
2473  {
2474  m_name = std::move(_name);
2475  }
2476 
2477  RTPS_DllAPI inline const MemberName& name() const
2478  {
2479  return m_name;
2480  }
2481 
2482  RTPS_DllAPI inline MemberName& name()
2483  {
2484  return m_name;
2485  }
2486 
2487  RTPS_DllAPI inline void default_value(
2488  const AnnotationParameterValue& _default_value)
2489  {
2490  m_default_value = _default_value;
2491  }
2492 
2493  RTPS_DllAPI inline void default_value(
2494  AnnotationParameterValue&& _default_value)
2495  {
2496  m_default_value = std::move(_default_value);
2497  }
2498 
2499  RTPS_DllAPI inline const AnnotationParameterValue& default_value() const
2500  {
2501  return m_default_value;
2502  }
2503 
2505  {
2506  return m_default_value;
2507  }
2508 
2509 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2510  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::getCdrSerializedSize()",
2511  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2512  RTPS_DllAPI static size_t getCdrSerializedSize(
2513  const MinimalAnnotationParameter& data,
2514  size_t current_alignment = 0);
2515  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::serialize()",
2516  "In favor of version using eprosima::fastcdr::serialize.")
2517  RTPS_DllAPI void serialize(
2518  eprosima::fastcdr::Cdr& cdr) const;
2519  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::deserialize()",
2520  "In favor of version using eprosima::fastcdr::deserialize.")
2521  RTPS_DllAPI void deserialize(
2522  eprosima::fastcdr::Cdr& cdr);
2523 #endif // DOXYGEN_SHOULD_SKIP_THIS
2524 
2525  RTPS_DllAPI bool operator ==(
2526  const MinimalAnnotationParameter& other) const;
2527 
2528  RTPS_DllAPI bool consistent(
2529  const MinimalAnnotationParameter& x,
2530  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2531 
2532 private:
2533 
2534  CommonAnnotationParameter m_common;
2535  MemberName m_name;
2536  AnnotationParameterValue m_default_value;
2537 };
2538 
2539 // Ordered by MinimalAnnotationParameter.name_hash
2540 typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
2541 /*struct CompleteAnnotationHeader {
2542  QualifiedTypeName annotation_name;
2543  };*/
2545 {
2546 public:
2547 
2551  const CompleteAnnotationHeader& x);
2555  const CompleteAnnotationHeader& x);
2558 
2559  RTPS_DllAPI inline void annotation_name(
2560  const QualifiedTypeName& _annotation_name)
2561  {
2562  m_annotation_name = _annotation_name;
2563  }
2564 
2565  RTPS_DllAPI inline void annotation_name(
2566  QualifiedTypeName&& _annotation_name)
2567  {
2568  m_annotation_name = std::move(_annotation_name);
2569  }
2570 
2571  RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const
2572  {
2573  return m_annotation_name;
2574  }
2575 
2576  RTPS_DllAPI inline QualifiedTypeName& annotation_name()
2577  {
2578  return m_annotation_name;
2579  }
2580 
2581 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2582  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::getCdrSerializedSize()",
2583  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2584  RTPS_DllAPI static size_t getCdrSerializedSize(
2585  const CompleteAnnotationHeader& data,
2586  size_t current_alignment = 0);
2587  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::serialize()",
2588  "In favor of version using eprosima::fastcdr::serialize.")
2589  RTPS_DllAPI void serialize(
2590  eprosima::fastcdr::Cdr& cdr) const;
2591  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::deserialize()",
2592  "In favor of version using eprosima::fastcdr::deserialize.")
2593  RTPS_DllAPI void deserialize(
2594  eprosima::fastcdr::Cdr& cdr);
2595 #endif // DOXYGEN_SHOULD_SKIP_THIS
2596 
2597  RTPS_DllAPI bool operator ==(
2598  const CompleteAnnotationHeader& other) const;
2599 
2600  RTPS_DllAPI bool consistent(
2601  const CompleteAnnotationHeader& x,
2602  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2603 
2604 private:
2605 
2606  QualifiedTypeName m_annotation_name;
2607 };
2608 
2609 /*struct MinimalAnnotationHeader {
2610  // Empty. Available for future extension
2611  };*/
2613 {
2614 public:
2615 
2619  const MinimalAnnotationHeader& x);
2623  const MinimalAnnotationHeader& x);
2626 
2627 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2628  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::getCdrSerializedSize()",
2629  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2630  RTPS_DllAPI static size_t getCdrSerializedSize(
2631  const MinimalAnnotationHeader& data,
2632  size_t current_alignment = 0);
2633  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::serialize()",
2634  "In favor of version using eprosima::fastcdr::serialize.")
2635  RTPS_DllAPI void serialize(
2636  eprosima::fastcdr::Cdr& cdr) const;
2637  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::deserialize()",
2638  "In favor of version using eprosima::fastcdr::deserialize.")
2639  RTPS_DllAPI void deserialize(
2640  eprosima::fastcdr::Cdr& cdr);
2641 #endif // DOXYGEN_SHOULD_SKIP_THIS
2642 
2643  RTPS_DllAPI bool operator ==(
2644  const MinimalAnnotationHeader&) const
2645  {
2646  return true;
2647  }
2648 
2649  RTPS_DllAPI bool consistent(
2650  const MinimalAnnotationHeader& x,
2651  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2652 
2653 private:
2654 
2655 };
2656 
2657 /*struct CompleteAnnotationType final{
2658  AnnotationTypeFlag annotation_flag;
2659  CompleteAnnotationHeader header;
2660  CompleteAnnotationParameterSeq member_seq;
2661  };*/
2663 {
2664 public:
2665 
2666  RTPS_DllAPI CompleteAnnotationType();
2669  const CompleteAnnotationType& x);
2673  const CompleteAnnotationType& x);
2676 
2677  RTPS_DllAPI inline void annotation_flag(
2678  const AnnotationTypeFlag& _annotation_flag)
2679  {
2680  m_annotation_flag = _annotation_flag;
2681  }
2682 
2683  RTPS_DllAPI inline void annotation_flag(
2684  AnnotationTypeFlag&& _annotation_flag)
2685  {
2686  m_annotation_flag = std::move(_annotation_flag);
2687  }
2688 
2689  RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const
2690  {
2691  return m_annotation_flag;
2692  }
2693 
2694  RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag()
2695  {
2696  return m_annotation_flag;
2697  }
2698 
2699  RTPS_DllAPI inline void header(
2700  const CompleteAnnotationHeader& _header)
2701  {
2702  m_header = _header;
2703  }
2704 
2705  RTPS_DllAPI inline void header(
2706  CompleteAnnotationHeader&& _header)
2707  {
2708  m_header = std::move(_header);
2709  }
2710 
2711  RTPS_DllAPI inline const CompleteAnnotationHeader& header() const
2712  {
2713  return m_header;
2714  }
2715 
2716  RTPS_DllAPI inline CompleteAnnotationHeader& header()
2717  {
2718  return m_header;
2719  }
2720 
2721  RTPS_DllAPI inline void member_seq(
2722  const CompleteAnnotationParameterSeq& _member_seq)
2723  {
2724  m_member_seq = _member_seq;
2725  }
2726 
2727  RTPS_DllAPI inline void member_seq(
2728  CompleteAnnotationParameterSeq&& _member_seq)
2729  {
2730  m_member_seq = std::move(_member_seq);
2731  }
2732 
2733  RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const
2734  {
2735  return m_member_seq;
2736  }
2737 
2739  {
2740  return m_member_seq;
2741  }
2742 
2743 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2744  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::getCdrSerializedSize()",
2745  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2746  RTPS_DllAPI static size_t getCdrSerializedSize(
2747  const CompleteAnnotationType& data,
2748  size_t current_alignment = 0);
2749  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::serialize()",
2750  "In favor of version using eprosima::fastcdr::serialize.")
2751  RTPS_DllAPI void serialize(
2752  eprosima::fastcdr::Cdr& cdr) const;
2753  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::deserialize()",
2754  "In favor of version using eprosima::fastcdr::deserialize.")
2755  RTPS_DllAPI void deserialize(
2756  eprosima::fastcdr::Cdr& cdr);
2757 #endif // DOXYGEN_SHOULD_SKIP_THIS
2758 
2759  RTPS_DllAPI bool operator ==(
2760  const CompleteAnnotationType& other) const;
2761 
2762  RTPS_DllAPI bool consistent(
2763  const CompleteAnnotationType& x,
2764  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2765 
2766 private:
2767 
2768  AnnotationTypeFlag m_annotation_flag;
2769  CompleteAnnotationHeader m_header;
2770  CompleteAnnotationParameterSeq m_member_seq;
2771 };
2772 /*struct MinimalAnnotationType final{
2773  AnnotationTypeFlag annotation_flag;
2774  MinimalAnnotationHeader header;
2775  MinimalAnnotationParameterSeq member_seq;
2776  };*/
2778 {
2779 public:
2780 
2781  RTPS_DllAPI MinimalAnnotationType();
2782  RTPS_DllAPI ~MinimalAnnotationType();
2784  const MinimalAnnotationType& x);
2786  MinimalAnnotationType&& x);
2788  const MinimalAnnotationType& x);
2790  MinimalAnnotationType&& x);
2791 
2792  RTPS_DllAPI inline void annotation_flag(
2793  const AnnotationTypeFlag& _annotation_flag)
2794  {
2795  m_annotation_flag = _annotation_flag;
2796  }
2797 
2798  RTPS_DllAPI inline void annotation_flag(
2799  AnnotationTypeFlag&& _annotation_flag)
2800  {
2801  m_annotation_flag = std::move(_annotation_flag);
2802  }
2803 
2804  RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const
2805  {
2806  return m_annotation_flag;
2807  }
2808 
2809  RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag()
2810  {
2811  return m_annotation_flag;
2812  }
2813 
2814  RTPS_DllAPI inline void header(
2815  const MinimalAnnotationHeader& _header)
2816  {
2817  m_header = _header;
2818  }
2819 
2820  RTPS_DllAPI inline void header(
2821  MinimalAnnotationHeader&& _header)
2822  {
2823  m_header = std::move(_header);
2824  }
2825 
2826  RTPS_DllAPI inline const MinimalAnnotationHeader& header() const
2827  {
2828  return m_header;
2829  }
2830 
2831  RTPS_DllAPI inline MinimalAnnotationHeader& header()
2832  {
2833  return m_header;
2834  }
2835 
2836  RTPS_DllAPI inline void member_seq(
2837  const MinimalAnnotationParameterSeq& _member_seq)
2838  {
2839  m_member_seq = _member_seq;
2840  }
2841 
2842  RTPS_DllAPI inline void member_seq(
2843  MinimalAnnotationParameterSeq&& _member_seq)
2844  {
2845  m_member_seq = std::move(_member_seq);
2846  }
2847 
2848  RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const
2849  {
2850  return m_member_seq;
2851  }
2852 
2854  {
2855  return m_member_seq;
2856  }
2857 
2858 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2859  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::getCdrSerializedSize()",
2860  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2861  RTPS_DllAPI static size_t getCdrSerializedSize(
2862  const MinimalAnnotationType& data,
2863  size_t current_alignment = 0);
2864  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::serialize()",
2865  "In favor of version using eprosima::fastcdr::serialize.")
2866  RTPS_DllAPI void serialize(
2867  eprosima::fastcdr::Cdr& cdr) const;
2868  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::deserialize()",
2869  "In favor of version using eprosima::fastcdr::deserialize.")
2870  RTPS_DllAPI void deserialize(
2871  eprosima::fastcdr::Cdr& cdr);
2872 #endif // DOXYGEN_SHOULD_SKIP_THIS
2873 
2874  RTPS_DllAPI bool operator ==(
2875  const MinimalAnnotationType& other) const;
2876 
2877  RTPS_DllAPI bool consistent(
2878  const MinimalAnnotationType& x,
2879  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2880 
2881 private:
2882 
2883  AnnotationTypeFlag m_annotation_flag;
2884  MinimalAnnotationHeader m_header;
2885  MinimalAnnotationParameterSeq m_member_seq;
2886 };
2887 
2888 // --- Alias: ---------------------------------------------------------
2889 /*struct CommonAliasBody final{
2890  AliasMemberFlag related_flags;
2891  TypeIdentifier related_type;
2892  };*/
2894 {
2895 public:
2896 
2897  RTPS_DllAPI CommonAliasBody();
2898  RTPS_DllAPI ~CommonAliasBody();
2899  RTPS_DllAPI CommonAliasBody(
2900  const CommonAliasBody& x);
2901  RTPS_DllAPI CommonAliasBody(
2902  CommonAliasBody&& x);
2904  const CommonAliasBody& x);
2906  CommonAliasBody&& x);
2907 
2908  RTPS_DllAPI inline void related_flags(
2909  const AliasMemberFlag& _related_flags)
2910  {
2911  m_related_flags = _related_flags;
2912  }
2913 
2914  RTPS_DllAPI inline void related_flags(
2915  AliasMemberFlag&& _related_flags)
2916  {
2917  m_related_flags = std::move(_related_flags);
2918  }
2919 
2920  RTPS_DllAPI inline const AliasMemberFlag& related_flags() const
2921  {
2922  return m_related_flags;
2923  }
2924 
2925  RTPS_DllAPI inline AliasMemberFlag& related_flags()
2926  {
2927  return m_related_flags;
2928  }
2929 
2930  RTPS_DllAPI inline void related_type(
2931  const TypeIdentifier& _related_type)
2932  {
2933  m_related_type = _related_type;
2934  }
2935 
2936  RTPS_DllAPI inline void related_type(
2937  TypeIdentifier&& _related_type)
2938  {
2939  m_related_type = std::move(_related_type);
2940  }
2941 
2942  RTPS_DllAPI inline const TypeIdentifier& related_type() const
2943  {
2944  return m_related_type;
2945  }
2946 
2947  RTPS_DllAPI inline TypeIdentifier& related_type()
2948  {
2949  return m_related_type;
2950  }
2951 
2952 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2953  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::getCdrSerializedSize()",
2954  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2955  RTPS_DllAPI static size_t getCdrSerializedSize(
2956  const CommonAliasBody& data,
2957  size_t current_alignment = 0);
2958  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::serialize()",
2959  "In favor of version using eprosima::fastcdr::serialize.")
2960  RTPS_DllAPI void serialize(
2961  eprosima::fastcdr::Cdr& cdr) const;
2962  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::deserialize()",
2963  "In favor of version using eprosima::fastcdr::deserialize.")
2964  RTPS_DllAPI void deserialize(
2965  eprosima::fastcdr::Cdr& cdr);
2966 #endif // DOXYGEN_SHOULD_SKIP_THIS
2967 
2968  RTPS_DllAPI bool operator ==(
2969  const CommonAliasBody& other) const;
2970 
2971  // RTPS_DllAPI bool consistent(const CommonAliasBody &x,
2972  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2973 
2974 private:
2975 
2976  AliasMemberFlag m_related_flags;
2977  TypeIdentifier m_related_type;
2978 };
2979 
2980 /*struct CompleteAliasBody {
2981  CommonAliasBody common;
2982  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
2983  AppliedAnnotationSeq ann_custom; // Optional
2984  };*/
2986 {
2987 public:
2988 
2989  RTPS_DllAPI CompleteAliasBody();
2990  RTPS_DllAPI ~CompleteAliasBody();
2991  RTPS_DllAPI CompleteAliasBody(
2992  const CompleteAliasBody& x);
2993  RTPS_DllAPI CompleteAliasBody(
2994  CompleteAliasBody&& x);
2996  const CompleteAliasBody& x);
2998  CompleteAliasBody&& x);
2999 
3000  RTPS_DllAPI inline void common(
3001  const CommonAliasBody& _common)
3002  {
3003  m_common = _common;
3004  }
3005 
3006  RTPS_DllAPI inline void common(
3007  CommonAliasBody&& _common)
3008  {
3009  m_common = std::move(_common);
3010  }
3011 
3012  RTPS_DllAPI inline const CommonAliasBody& common() const
3013  {
3014  return m_common;
3015  }
3016 
3017  RTPS_DllAPI inline CommonAliasBody& common()
3018  {
3019  return m_common;
3020  }
3021 
3022  RTPS_DllAPI inline void ann_builtin(
3023  const AppliedBuiltinMemberAnnotations& _ann_builtin)
3024  {
3025  m_ann_builtin = _ann_builtin;
3026  }
3027 
3028  RTPS_DllAPI inline void ann_builtin(
3029  AppliedBuiltinMemberAnnotations&& _ann_builtin)
3030  {
3031  m_ann_builtin = std::move(_ann_builtin);
3032  }
3033 
3034  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
3035  {
3036  return m_ann_builtin;
3037  }
3038 
3040  {
3041  return m_ann_builtin;
3042  }
3043 
3044  RTPS_DllAPI inline void ann_custom(
3045  const AppliedAnnotationSeq& _ann_custom)
3046  {
3047  m_ann_custom = _ann_custom;
3048  }
3049 
3050  RTPS_DllAPI inline void ann_custom(
3051  AppliedAnnotationSeq&& _ann_custom)
3052  {
3053  m_ann_custom = std::move(_ann_custom);
3054  }
3055 
3056  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
3057  {
3058  return m_ann_custom;
3059  }
3060 
3061  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
3062  {
3063  return m_ann_custom;
3064  }
3065 
3066 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3067  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::getCdrSerializedSize()",
3068  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3069  RTPS_DllAPI static size_t getCdrSerializedSize(
3070  const CompleteAliasBody& data,
3071  size_t current_alignment = 0);
3072  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::serialize()",
3073  "In favor of version using eprosima::fastcdr::serialize.")
3074  RTPS_DllAPI void serialize(
3075  eprosima::fastcdr::Cdr& cdr) const;
3076  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::deserialize()",
3077  "In favor of version using eprosima::fastcdr::deserialize.")
3078  RTPS_DllAPI void deserialize(
3079  eprosima::fastcdr::Cdr& cdr);
3080 #endif // DOXYGEN_SHOULD_SKIP_THIS
3081 
3082  RTPS_DllAPI bool operator ==(
3083  const CompleteAliasBody& other) const;
3084 
3085  // RTPS_DllAPI bool consistent(const CompleteAliasBody &x,
3086  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3087 
3088 private:
3089 
3090  CommonAliasBody m_common;
3091  AppliedBuiltinMemberAnnotations m_ann_builtin;
3092  AppliedAnnotationSeq m_ann_custom;
3093 };
3094 
3095 /*struct MinimalAliasBody {
3096  CommonAliasBody common;
3097  };*/
3099 {
3100 public:
3101 
3102  RTPS_DllAPI MinimalAliasBody();
3103  RTPS_DllAPI ~MinimalAliasBody();
3104  RTPS_DllAPI MinimalAliasBody(
3105  const MinimalAliasBody& x);
3106  RTPS_DllAPI MinimalAliasBody(
3107  MinimalAliasBody&& x);
3109  const MinimalAliasBody& x);
3111  MinimalAliasBody&& x);
3112 
3113  RTPS_DllAPI inline void common(
3114  const CommonAliasBody& _common)
3115  {
3116  m_common = _common;
3117  }
3118 
3119  RTPS_DllAPI inline void common(
3120  CommonAliasBody&& _common)
3121  {
3122  m_common = std::move(_common);
3123  }
3124 
3125  RTPS_DllAPI inline const CommonAliasBody& common() const
3126  {
3127  return m_common;
3128  }
3129 
3130  RTPS_DllAPI inline CommonAliasBody& common()
3131  {
3132  return m_common;
3133  }
3134 
3135 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3136  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::getCdrSerializedSize()",
3137  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3138  RTPS_DllAPI static size_t getCdrSerializedSize(
3139  const MinimalAliasBody& data,
3140  size_t current_alignment = 0);
3141  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::serialize()",
3142  "In favor of version using eprosima::fastcdr::serialize.")
3143  RTPS_DllAPI void serialize(
3144  eprosima::fastcdr::Cdr& cdr) const;
3145  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::deserialize()",
3146  "In favor of version using eprosima::fastcdr::deserialize.")
3147  RTPS_DllAPI void deserialize(
3148  eprosima::fastcdr::Cdr& cdr);
3149 #endif // DOXYGEN_SHOULD_SKIP_THIS
3150 
3151  RTPS_DllAPI bool operator ==(
3152  const MinimalAliasBody& other) const;
3153 
3154  // RTPS_DllAPI bool consistent(const MinimalAliasBody &x,
3155  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3156 
3157 private:
3158 
3159  CommonAliasBody m_common;
3160 };
3161 
3162 /*struct CompleteAliasHeader {
3163  CompleteTypeDetail detail;
3164  };*/
3166 {
3167 public:
3168 
3169  RTPS_DllAPI CompleteAliasHeader();
3170  RTPS_DllAPI ~CompleteAliasHeader();
3171  RTPS_DllAPI CompleteAliasHeader(
3172  const CompleteAliasHeader& x);
3173  RTPS_DllAPI CompleteAliasHeader(
3174  CompleteAliasHeader&& x);
3176  const CompleteAliasHeader& x);
3178  CompleteAliasHeader&& x);
3179 
3180  RTPS_DllAPI inline void detail(
3181  const CompleteTypeDetail& _detail)
3182  {
3183  m_detail = _detail;
3184  }
3185 
3186  RTPS_DllAPI inline void detail(
3187  CompleteTypeDetail&& _detail)
3188  {
3189  m_detail = std::move(_detail);
3190  }
3191 
3192  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
3193  {
3194  return m_detail;
3195  }
3196 
3197  RTPS_DllAPI inline CompleteTypeDetail& detail()
3198  {
3199  return m_detail;
3200  }
3201 
3202 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3203  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::getCdrSerializedSize()",
3204  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3205  RTPS_DllAPI static size_t getCdrSerializedSize(
3206  const CompleteAliasHeader& data,
3207  size_t current_alignment = 0);
3208  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::serialize()",
3209  "In favor of version using eprosima::fastcdr::serialize.")
3210  RTPS_DllAPI void serialize(
3211  eprosima::fastcdr::Cdr& cdr) const;
3212  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::deserialize()",
3213  "In favor of version using eprosima::fastcdr::deserialize.")
3214  RTPS_DllAPI void deserialize(
3215  eprosima::fastcdr::Cdr& cdr);
3216 #endif // DOXYGEN_SHOULD_SKIP_THIS
3217 
3218  RTPS_DllAPI bool operator ==(
3219  const CompleteAliasHeader& other) const;
3220 
3221  // RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,
3222  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3223 
3224 private:
3225 
3226  CompleteTypeDetail m_detail;
3227 };
3228 
3229 /*struct MinimalAliasHeader {
3230  // Empty. Available for future extension
3231  };*/
3233 {
3234 public:
3235 
3236  RTPS_DllAPI MinimalAliasHeader();
3237  RTPS_DllAPI ~MinimalAliasHeader();
3238  RTPS_DllAPI MinimalAliasHeader(
3239  const MinimalAliasHeader& x);
3240  RTPS_DllAPI MinimalAliasHeader(
3241  MinimalAliasHeader&& x);
3243  const MinimalAliasHeader& x);
3245  MinimalAliasHeader&& x);
3246 
3247 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3248  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::getCdrSerializedSize()",
3249  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3250  RTPS_DllAPI static size_t getCdrSerializedSize(
3251  const MinimalAliasHeader& data,
3252  size_t current_alignment = 0);
3253  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::serialize()",
3254  "In favor of version using eprosima::fastcdr::serialize.")
3255  RTPS_DllAPI void serialize(
3256  eprosima::fastcdr::Cdr& cdr) const;
3257  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::deserialize()",
3258  "In favor of version using eprosima::fastcdr::deserialize.")
3259  RTPS_DllAPI void deserialize(
3260  eprosima::fastcdr::Cdr& cdr);
3261 #endif // DOXYGEN_SHOULD_SKIP_THIS
3262 
3263  RTPS_DllAPI bool operator ==(
3264  const MinimalAliasHeader&) const
3265  {
3266  return true;
3267  }
3268 
3269  // RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,
3270  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3271 
3272 private:
3273 
3274 };
3275 
3276 /*struct CompleteAliasType final{
3277  AliasTypeFlag alias_flags;
3278  CompleteAliasHeader header;
3279  CompleteAliasBody body;
3280  };*/
3282 {
3283 public:
3284 
3285  RTPS_DllAPI CompleteAliasType();
3286  RTPS_DllAPI ~CompleteAliasType();
3287  RTPS_DllAPI CompleteAliasType(
3288  const CompleteAliasType& x);
3289  RTPS_DllAPI CompleteAliasType(
3290  CompleteAliasType&& x);
3292  const CompleteAliasType& x);
3294  CompleteAliasType&& x);
3295 
3296  RTPS_DllAPI inline void alias_flags(
3297  const AliasTypeFlag& _alias_flags)
3298  {
3299  m_alias_flags = _alias_flags;
3300  }
3301 
3302  RTPS_DllAPI inline void alias_flags(
3303  AliasTypeFlag&& _alias_flags)
3304  {
3305  m_alias_flags = std::move(_alias_flags);
3306  }
3307 
3308  RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const
3309  {
3310  return m_alias_flags;
3311  }
3312 
3313  RTPS_DllAPI inline AliasTypeFlag& alias_flags()
3314  {
3315  return m_alias_flags;
3316  }
3317 
3318  RTPS_DllAPI inline void header(
3319  const CompleteAliasHeader& _header)
3320  {
3321  m_header = _header;
3322  }
3323 
3324  RTPS_DllAPI inline void header(
3325  CompleteAliasHeader&& _header)
3326  {
3327  m_header = std::move(_header);
3328  }
3329 
3330  RTPS_DllAPI inline const CompleteAliasHeader& header() const
3331  {
3332  return m_header;
3333  }
3334 
3335  RTPS_DllAPI inline CompleteAliasHeader& header()
3336  {
3337  return m_header;
3338  }
3339 
3340  RTPS_DllAPI inline void body(
3341  const CompleteAliasBody& _body)
3342  {
3343  m_body = _body;
3344  }
3345 
3346  RTPS_DllAPI inline void body(
3347  CompleteAliasBody&& _body)
3348  {
3349  m_body = std::move(_body);
3350  }
3351 
3352  RTPS_DllAPI inline const CompleteAliasBody& body() const
3353  {
3354  return m_body;
3355  }
3356 
3357  RTPS_DllAPI inline CompleteAliasBody& body()
3358  {
3359  return m_body;
3360  }
3361 
3362 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3363  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::getCdrSerializedSize()",
3364  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3365  RTPS_DllAPI static size_t getCdrSerializedSize(
3366  const CompleteAliasType& data,
3367  size_t current_alignment = 0);
3368  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::serialize()",
3369  "In favor of version using eprosima::fastcdr::serialize.")
3370  RTPS_DllAPI void serialize(
3371  eprosima::fastcdr::Cdr& cdr) const;
3372  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::deserialize()",
3373  "In favor of version using eprosima::fastcdr::deserialize.")
3374  RTPS_DllAPI void deserialize(
3375  eprosima::fastcdr::Cdr& cdr);
3376 #endif // DOXYGEN_SHOULD_SKIP_THIS
3377 
3378  RTPS_DllAPI bool operator ==(
3379  const CompleteAliasType& other) const;
3380 
3381  // RTPS_DllAPI bool consistent(const CompleteAliasType &x,
3382  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3383 
3384 private:
3385 
3386  AliasTypeFlag m_alias_flags;
3387  CompleteAliasHeader m_header;
3388  CompleteAliasBody m_body;
3389 };
3390 /*struct MinimalAliasType final{
3391  AliasTypeFlag alias_flags;
3392  MinimalAliasHeader header;
3393  MinimalAliasBody body;
3394  };*/
3396 {
3397 public:
3398 
3399  RTPS_DllAPI MinimalAliasType();
3400  RTPS_DllAPI ~MinimalAliasType();
3401  RTPS_DllAPI MinimalAliasType(
3402  const MinimalAliasType& x);
3403  RTPS_DllAPI MinimalAliasType(
3404  MinimalAliasType&& x);
3406  const MinimalAliasType& x);
3408  MinimalAliasType&& x);
3409 
3410  RTPS_DllAPI inline void alias_flags(
3411  const AliasTypeFlag& _alias_flags)
3412  {
3413  m_alias_flags = _alias_flags;
3414  }
3415 
3416  RTPS_DllAPI inline void alias_flags(
3417  AliasTypeFlag&& _alias_flags)
3418  {
3419  m_alias_flags = std::move(_alias_flags);
3420  }
3421 
3422  RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const
3423  {
3424  return m_alias_flags;
3425  }
3426 
3427  RTPS_DllAPI inline AliasTypeFlag& alias_flags()
3428  {
3429  return m_alias_flags;
3430  }
3431 
3432  RTPS_DllAPI inline void header(
3433  const MinimalAliasHeader& _header)
3434  {
3435  m_header = _header;
3436  }
3437 
3438  RTPS_DllAPI inline void header(
3439  MinimalAliasHeader&& _header)
3440  {
3441  m_header = std::move(_header);
3442  }
3443 
3444  RTPS_DllAPI inline const MinimalAliasHeader& header() const
3445  {
3446  return m_header;
3447  }
3448 
3449  RTPS_DllAPI inline MinimalAliasHeader& header()
3450  {
3451  return m_header;
3452  }
3453 
3454  RTPS_DllAPI inline void body(
3455  const MinimalAliasBody& _body)
3456  {
3457  m_body = _body;
3458  }
3459 
3460  RTPS_DllAPI inline void body(
3461  MinimalAliasBody&& _body)
3462  {
3463  m_body = std::move(_body);
3464  }
3465 
3466  RTPS_DllAPI inline const MinimalAliasBody& body() const
3467  {
3468  return m_body;
3469  }
3470 
3471  RTPS_DllAPI inline MinimalAliasBody& body()
3472  {
3473  return m_body;
3474  }
3475 
3476 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3477  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::getCdrSerializedSize()",
3478  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3479  RTPS_DllAPI static size_t getCdrSerializedSize(
3480  const MinimalAliasType& data,
3481  size_t current_alignment = 0);
3482  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::serialize()",
3483  "In favor of version using eprosima::fastcdr::serialize.")
3484  RTPS_DllAPI void serialize(
3485  eprosima::fastcdr::Cdr& cdr) const;
3486  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::deserialize()",
3487  "In favor of version using eprosima::fastcdr::deserialize.")
3488  RTPS_DllAPI void deserialize(
3489  eprosima::fastcdr::Cdr& cdr);
3490 #endif // DOXYGEN_SHOULD_SKIP_THIS
3491 
3492  RTPS_DllAPI bool operator ==(
3493  const MinimalAliasType& other) const;
3494 
3495  // RTPS_DllAPI bool consistent(const MinimalAliasType &x,
3496  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3497 
3498 private:
3499 
3500  AliasTypeFlag m_alias_flags;
3501  MinimalAliasHeader m_header;
3502  MinimalAliasBody m_body;
3503 };
3504 
3505 // --- Collections: ---------------------------------------------------
3506 /*struct CompleteElementDetail final{
3507  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
3508  AppliedAnnotationSeq ann_custom; // Optional
3509  };*/
3511 {
3512 public:
3513 
3514  RTPS_DllAPI CompleteElementDetail();
3515  RTPS_DllAPI ~CompleteElementDetail();
3517  const CompleteElementDetail& x);
3519  CompleteElementDetail&& x);
3521  const CompleteElementDetail& x);
3523  CompleteElementDetail&& x);
3524 
3525  RTPS_DllAPI inline void ann_builtin(
3526  const AppliedBuiltinMemberAnnotations& _ann_builtin)
3527  {
3528  m_ann_builtin = _ann_builtin;
3529  }
3530 
3531  RTPS_DllAPI inline void ann_builtin(
3532  AppliedBuiltinMemberAnnotations&& _ann_builtin)
3533  {
3534  m_ann_builtin = std::move(_ann_builtin);
3535  }
3536 
3537  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
3538  {
3539  return m_ann_builtin;
3540  }
3541 
3543  {
3544  return m_ann_builtin;
3545  }
3546 
3547  RTPS_DllAPI inline void ann_custom(
3548  const AppliedAnnotationSeq& _ann_custom)
3549  {
3550  m_ann_custom = _ann_custom;
3551  }
3552 
3553  RTPS_DllAPI inline void ann_custom(
3554  AppliedAnnotationSeq&& _ann_custom)
3555  {
3556  m_ann_custom = std::move(_ann_custom);
3557  }
3558 
3559  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
3560  {
3561  return m_ann_custom;
3562  }
3563 
3564  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
3565  {
3566  return m_ann_custom;
3567  }
3568 
3569 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3570  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::getCdrSerializedSize()",
3571  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3572  RTPS_DllAPI static size_t getCdrSerializedSize(
3573  const CompleteElementDetail& data,
3574  size_t current_alignment = 0);
3575  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::serialize()",
3576  "In favor of version using eprosima::fastcdr::serialize.")
3577  RTPS_DllAPI void serialize(
3578  eprosima::fastcdr::Cdr& cdr) const;
3579  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::deserialize()",
3580  "In favor of version using eprosima::fastcdr::deserialize.")
3581  RTPS_DllAPI void deserialize(
3582  eprosima::fastcdr::Cdr& cdr);
3583 #endif // DOXYGEN_SHOULD_SKIP_THIS
3584 
3585  RTPS_DllAPI bool operator ==(
3586  const CompleteElementDetail& other) const;
3587 
3588  RTPS_DllAPI bool consistent(
3589  const CompleteElementDetail& x,
3590  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3591 
3592 private:
3593 
3594  AppliedBuiltinMemberAnnotations m_ann_builtin;
3595  AppliedAnnotationSeq m_ann_custom;
3596 };
3597 /*struct CommonCollectionElement final{
3598  CollectionElementFlag element_flags;
3599  TypeIdentifier type;
3600  };*/
3602 {
3603 public:
3604 
3608  const CommonCollectionElement& x);
3612  const CommonCollectionElement& x);
3615 
3616  RTPS_DllAPI inline void element_flags(
3617  const CollectionElementFlag& _element_flags)
3618  {
3619  m_element_flags = _element_flags;
3620  }
3621 
3622  RTPS_DllAPI inline void element_flags(
3623  CollectionElementFlag&& _element_flags)
3624  {
3625  m_element_flags = std::move(_element_flags);
3626  }
3627 
3628  RTPS_DllAPI inline const CollectionElementFlag& element_flags() const
3629  {
3630  return m_element_flags;
3631  }
3632 
3633  RTPS_DllAPI inline CollectionElementFlag& element_flags()
3634  {
3635  return m_element_flags;
3636  }
3637 
3638  RTPS_DllAPI inline void type(
3639  const TypeIdentifier& _type)
3640  {
3641  m_type = _type;
3642  }
3643 
3644  RTPS_DllAPI inline void type(
3645  TypeIdentifier&& _type)
3646  {
3647  m_type = std::move(_type);
3648  }
3649 
3650  RTPS_DllAPI inline const TypeIdentifier& type() const
3651  {
3652  return m_type;
3653  }
3654 
3655  RTPS_DllAPI inline TypeIdentifier& type()
3656  {
3657  return m_type;
3658  }
3659 
3660 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3661  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::getCdrSerializedSize()",
3662  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3663  RTPS_DllAPI static size_t getCdrSerializedSize(
3664  const CommonCollectionElement& data,
3665  size_t current_alignment = 0);
3666  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::serialize()",
3667  "In favor of version using eprosima::fastcdr::serialize.")
3668  RTPS_DllAPI void serialize(
3669  eprosima::fastcdr::Cdr& cdr) const;
3670  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::deserialize()",
3671  "In favor of version using eprosima::fastcdr::deserialize.")
3672  RTPS_DllAPI void deserialize(
3673  eprosima::fastcdr::Cdr& cdr);
3674 #endif // DOXYGEN_SHOULD_SKIP_THIS
3675 
3676  RTPS_DllAPI bool operator ==(
3677  const CommonCollectionElement& other) const;
3678 
3679  RTPS_DllAPI bool consistent(
3680  const CommonCollectionElement& x,
3681  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3682 
3683 private:
3684 
3685  CollectionElementFlag m_element_flags;
3686  TypeIdentifier m_type;
3687 };
3688 
3689 /*struct CompleteCollectionElement {
3690  CommonCollectionElement common;
3691  CompleteElementDetail detail;
3692  };*/
3694 {
3695 public:
3696 
3700  const CompleteCollectionElement& x);
3704  const CompleteCollectionElement& x);
3707 
3708  RTPS_DllAPI inline void common(
3709  const CommonCollectionElement& _common)
3710  {
3711  m_common = _common;
3712  }
3713 
3714  RTPS_DllAPI inline void common(
3715  CommonCollectionElement&& _common)
3716  {
3717  m_common = std::move(_common);
3718  }
3719 
3720  RTPS_DllAPI inline const CommonCollectionElement& common() const
3721  {
3722  return m_common;
3723  }
3724 
3725  RTPS_DllAPI inline CommonCollectionElement& common()
3726  {
3727  return m_common;
3728  }
3729 
3730  RTPS_DllAPI inline void detail(
3731  const CompleteElementDetail& _detail)
3732  {
3733  m_detail = _detail;
3734  }
3735 
3736  RTPS_DllAPI inline void detail(
3737  CompleteElementDetail&& _detail)
3738  {
3739  m_detail = std::move(_detail);
3740  }
3741 
3742  RTPS_DllAPI inline const CompleteElementDetail& detail() const
3743  {
3744  return m_detail;
3745  }
3746 
3747  RTPS_DllAPI inline CompleteElementDetail& detail()
3748  {
3749  return m_detail;
3750  }
3751 
3752 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3753  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::getCdrSerializedSize()",
3754  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3755  RTPS_DllAPI static size_t getCdrSerializedSize(
3756  const CompleteCollectionElement& data,
3757  size_t current_alignment = 0);
3758  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::serialize()",
3759  "In favor of version using eprosima::fastcdr::serialize.")
3760  RTPS_DllAPI void serialize(
3761  eprosima::fastcdr::Cdr& cdr) const;
3762  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::deserialize()",
3763  "In favor of version using eprosima::fastcdr::deserialize.")
3764  RTPS_DllAPI void deserialize(
3765  eprosima::fastcdr::Cdr& cdr);
3766 #endif // DOXYGEN_SHOULD_SKIP_THIS
3767 
3768  RTPS_DllAPI bool operator ==(
3769  const CompleteCollectionElement& other) const;
3770 
3771  RTPS_DllAPI bool consistent(
3772  const CompleteCollectionElement& x,
3773  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3774 
3775 private:
3776 
3777  CommonCollectionElement m_common;
3778  CompleteElementDetail m_detail;
3779 };
3780 
3781 /*struct MinimalCollectionElement {
3782  CommonCollectionElement common;
3783  };*/
3785 {
3786 public:
3787 
3791  const MinimalCollectionElement& x);
3795  const MinimalCollectionElement& x);
3798 
3799  RTPS_DllAPI inline void common(
3800  const CommonCollectionElement& _common)
3801  {
3802  m_common = _common;
3803  }
3804 
3805  RTPS_DllAPI inline void common(
3806  CommonCollectionElement&& _common)
3807  {
3808  m_common = std::move(_common);
3809  }
3810 
3811  RTPS_DllAPI inline const CommonCollectionElement& common() const
3812  {
3813  return m_common;
3814  }
3815 
3816  RTPS_DllAPI inline CommonCollectionElement& common()
3817  {
3818  return m_common;
3819  }
3820 
3821 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3822  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::getCdrSerializedSize()",
3823  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3824  RTPS_DllAPI static size_t getCdrSerializedSize(
3825  const MinimalCollectionElement& data,
3826  size_t current_alignment = 0);
3827  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::serialize()",
3828  "In favor of version using eprosima::fastcdr::serialize.")
3829  RTPS_DllAPI void serialize(
3830  eprosima::fastcdr::Cdr& cdr) const;
3831  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::deserialize()",
3832  "In favor of version using eprosima::fastcdr::deserialize.")
3833  RTPS_DllAPI void deserialize(
3834  eprosima::fastcdr::Cdr& cdr);
3835 #endif // DOXYGEN_SHOULD_SKIP_THIS
3836 
3837  RTPS_DllAPI bool operator ==(
3838  const MinimalCollectionElement& other) const;
3839 
3840  RTPS_DllAPI bool consistent(
3841  const MinimalCollectionElement& x,
3842  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3843 
3844 private:
3845 
3846  CommonCollectionElement m_common;
3847 };
3848 
3849 /*struct CommonCollectionHeader final{
3850  LBound bound;
3851  };*/
3853 {
3854 public:
3855 
3856  RTPS_DllAPI CommonCollectionHeader();
3859  const CommonCollectionHeader& x);
3863  const CommonCollectionHeader& x);
3866 
3867  RTPS_DllAPI inline void bound(
3868  const LBound& _bound)
3869  {
3870  m_bound = _bound;
3871  }
3872 
3873  RTPS_DllAPI inline void bound(
3874  LBound&& _bound)
3875  {
3876  m_bound = std::move(_bound);
3877  }
3878 
3879  RTPS_DllAPI inline const LBound& bound() const
3880  {
3881  return m_bound;
3882  }
3883 
3884  RTPS_DllAPI inline LBound& bound()
3885  {
3886  return m_bound;
3887  }
3888 
3889 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3890  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::getCdrSerializedSize()",
3891  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3892  RTPS_DllAPI static size_t getCdrSerializedSize(
3893  const CommonCollectionHeader& data,
3894  size_t current_alignment = 0);
3895  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::serialize()",
3896  "In favor of version using eprosima::fastcdr::serialize.")
3897  RTPS_DllAPI void serialize(
3898  eprosima::fastcdr::Cdr& cdr) const;
3899  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::deserialize()",
3900  "In favor of version using eprosima::fastcdr::deserialize.")
3901  RTPS_DllAPI void deserialize(
3902  eprosima::fastcdr::Cdr& cdr);
3903 #endif // DOXYGEN_SHOULD_SKIP_THIS
3904 
3905  RTPS_DllAPI bool operator ==(
3906  const CommonCollectionHeader& other) const;
3907 
3908  RTPS_DllAPI bool consistent(
3909  const CommonCollectionHeader& x,
3910  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3911 
3912 private:
3913 
3914  LBound m_bound;
3915 };
3916 
3917 /*struct CompleteCollectionHeader {
3918  CommonCollectionHeader common;
3919  CompleteTypeDetail detail; // Optional // not present for anonymous
3920  };*/
3922 {
3923 public:
3924 
3928  const CompleteCollectionHeader& x);
3932  const CompleteCollectionHeader& x);
3935 
3936  RTPS_DllAPI inline void common(
3937  const CommonCollectionHeader& _common)
3938  {
3939  m_common = _common;
3940  }
3941 
3942  RTPS_DllAPI inline void common(
3943  CommonCollectionHeader&& _common)
3944  {
3945  m_common = std::move(_common);
3946  }
3947 
3948  RTPS_DllAPI inline const CommonCollectionHeader& common() const
3949  {
3950  return m_common;
3951  }
3952 
3953  RTPS_DllAPI inline CommonCollectionHeader& common()
3954  {
3955  return m_common;
3956  }
3957 
3958  RTPS_DllAPI inline void detail(
3959  const CompleteTypeDetail& _detail)
3960  {
3961  m_detail = _detail;
3962  }
3963 
3964  RTPS_DllAPI inline void detail(
3965  CompleteTypeDetail&& _detail)
3966  {
3967  m_detail = std::move(_detail);
3968  }
3969 
3970  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
3971  {
3972  return m_detail;
3973  }
3974 
3975  RTPS_DllAPI inline CompleteTypeDetail& detail()
3976  {
3977  return m_detail;
3978  }
3979 
3980 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3981  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::getCdrSerializedSize()",
3982  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3983  RTPS_DllAPI static size_t getCdrSerializedSize(
3984  const CompleteCollectionHeader& data,
3985  size_t current_alignment = 0);
3986  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::serialize()",
3987  "In favor of version using eprosima::fastcdr::serialize.")
3988  RTPS_DllAPI void serialize(
3989  eprosima::fastcdr::Cdr& cdr) const;
3990  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::deserialize()",
3991  "In favor of version using eprosima::fastcdr::deserialize.")
3992  RTPS_DllAPI void deserialize(
3993  eprosima::fastcdr::Cdr& cdr);
3994 #endif // DOXYGEN_SHOULD_SKIP_THIS
3995 
3996  RTPS_DllAPI bool operator ==(
3997  const CompleteCollectionHeader& other) const;
3998 
3999  RTPS_DllAPI bool consistent(
4000  const CompleteCollectionHeader& x,
4001  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4002 
4003 private:
4004 
4005  CommonCollectionHeader m_common;
4006  CompleteTypeDetail m_detail;
4007 };
4008 
4009 /*struct MinimalCollectionHeader {
4010  CommonCollectionHeader common;
4011  };*/
4013 {
4014 public:
4015 
4019  const MinimalCollectionHeader& x);
4023  const MinimalCollectionHeader& x);
4026 
4027  RTPS_DllAPI inline void common(
4028  const CommonCollectionHeader& _common)
4029  {
4030  m_common = _common;
4031  }
4032 
4033  RTPS_DllAPI inline void common(
4034  CommonCollectionHeader&& _common)
4035  {
4036  m_common = std::move(_common);
4037  }
4038 
4039  RTPS_DllAPI inline const CommonCollectionHeader& common() const
4040  {
4041  return m_common;
4042  }
4043 
4044  RTPS_DllAPI inline CommonCollectionHeader& common()
4045  {
4046  return m_common;
4047  }
4048 
4049 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4050  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::getCdrSerializedSize()",
4051  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4052  RTPS_DllAPI static size_t getCdrSerializedSize(
4053  const MinimalCollectionHeader& data,
4054  size_t current_alignment = 0);
4055  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::serialize()",
4056  "In favor of version using eprosima::fastcdr::serialize.")
4057  RTPS_DllAPI void serialize(
4058  eprosima::fastcdr::Cdr& cdr) const;
4059  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::deserialize()",
4060  "In favor of version using eprosima::fastcdr::deserialize.")
4061  RTPS_DllAPI void deserialize(
4062  eprosima::fastcdr::Cdr& cdr);
4063 #endif // DOXYGEN_SHOULD_SKIP_THIS
4064 
4065  RTPS_DllAPI bool operator ==(
4066  const MinimalCollectionHeader& other) const;
4067 
4068  RTPS_DllAPI bool consistent(
4069  const MinimalCollectionHeader& x,
4070  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4071 
4072 private:
4073 
4074  CommonCollectionHeader m_common;
4075 };
4076 
4077 // --- Sequence: -----------------------------------------------------
4078 /*struct CompleteSequenceType final{
4079  CollectionTypeFlag collection_flag;
4080  CompleteCollectionHeader header;
4081  CompleteCollectionElement element;
4082  };*/
4084 {
4085 public:
4086 
4087  RTPS_DllAPI CompleteSequenceType();
4088  RTPS_DllAPI ~CompleteSequenceType();
4090  const CompleteSequenceType& x);
4092  CompleteSequenceType&& x);
4094  const CompleteSequenceType& x);
4096  CompleteSequenceType&& x);
4097 
4098  RTPS_DllAPI inline void collection_flag(
4099  const CollectionTypeFlag& _collection_flag)
4100  {
4101  m_collection_flag = _collection_flag;
4102  }
4103 
4104  RTPS_DllAPI inline void collection_flag(
4105  CollectionTypeFlag&& _collection_flag)
4106  {
4107  m_collection_flag = std::move(_collection_flag);
4108  }
4109 
4110  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4111  {
4112  return m_collection_flag;
4113  }
4114 
4115  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4116  {
4117  return m_collection_flag;
4118  }
4119 
4120  RTPS_DllAPI inline void header(
4121  const CompleteCollectionHeader& _header)
4122  {
4123  m_header = _header;
4124  }
4125 
4126  RTPS_DllAPI inline void header(
4127  CompleteCollectionHeader&& _header)
4128  {
4129  m_header = std::move(_header);
4130  }
4131 
4132  RTPS_DllAPI inline const CompleteCollectionHeader& header() const
4133  {
4134  return m_header;
4135  }
4136 
4137  RTPS_DllAPI inline CompleteCollectionHeader& header()
4138  {
4139  return m_header;
4140  }
4141 
4142  RTPS_DllAPI inline void element(
4143  const CompleteCollectionElement& _element)
4144  {
4145  m_element = _element;
4146  }
4147 
4148  RTPS_DllAPI inline void element(
4149  CompleteCollectionElement&& _element)
4150  {
4151  m_element = std::move(_element);
4152  }
4153 
4154  RTPS_DllAPI inline const CompleteCollectionElement& element() const
4155  {
4156  return m_element;
4157  }
4158 
4159  RTPS_DllAPI inline CompleteCollectionElement& element()
4160  {
4161  return m_element;
4162  }
4163 
4164 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4165  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::getCdrSerializedSize()",
4166  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4167  RTPS_DllAPI static size_t getCdrSerializedSize(
4168  const CompleteSequenceType& data,
4169  size_t current_alignment = 0);
4170  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::serialize()",
4171  "In favor of version using eprosima::fastcdr::serialize.")
4172  RTPS_DllAPI void serialize(
4173  eprosima::fastcdr::Cdr& cdr) const;
4174  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::deserialize()",
4175  "In favor of version using eprosima::fastcdr::deserialize.")
4176  RTPS_DllAPI void deserialize(
4177  eprosima::fastcdr::Cdr& cdr);
4178 #endif // DOXYGEN_SHOULD_SKIP_THIS
4179 
4180  RTPS_DllAPI bool operator ==(
4181  const CompleteSequenceType& other) const;
4182 
4183  RTPS_DllAPI bool consistent(
4184  const CompleteSequenceType& x,
4185  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4186 
4187 private:
4188 
4189  CollectionTypeFlag m_collection_flag;
4190  CompleteCollectionHeader m_header;
4191  CompleteCollectionElement m_element;
4192 };
4193 
4194 /*struct MinimalSequenceType final{
4195  CollectionTypeFlag collection_flag;
4196  MinimalCollectionHeader header;
4197  MinimalCollectionElement element;
4198  };*/
4200 {
4201 public:
4202 
4203  RTPS_DllAPI MinimalSequenceType();
4204  RTPS_DllAPI ~MinimalSequenceType();
4205  RTPS_DllAPI MinimalSequenceType(
4206  const MinimalSequenceType& x);
4207  RTPS_DllAPI MinimalSequenceType(
4208  MinimalSequenceType&& x);
4210  const MinimalSequenceType& x);
4212  MinimalSequenceType&& x);
4213 
4214  RTPS_DllAPI inline void collection_flag(
4215  const CollectionTypeFlag& _collection_flag)
4216  {
4217  m_collection_flag = _collection_flag;
4218  }
4219 
4220  RTPS_DllAPI inline void collection_flag(
4221  CollectionTypeFlag&& _collection_flag)
4222  {
4223  m_collection_flag = std::move(_collection_flag);
4224  }
4225 
4226  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4227  {
4228  return m_collection_flag;
4229  }
4230 
4231  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4232  {
4233  return m_collection_flag;
4234  }
4235 
4236  RTPS_DllAPI inline void header(
4237  const MinimalCollectionHeader& _header)
4238  {
4239  m_header = _header;
4240  }
4241 
4242  RTPS_DllAPI inline void header(
4243  MinimalCollectionHeader&& _header)
4244  {
4245  m_header = std::move(_header);
4246  }
4247 
4248  RTPS_DllAPI inline const MinimalCollectionHeader& header() const
4249  {
4250  return m_header;
4251  }
4252 
4253  RTPS_DllAPI inline MinimalCollectionHeader& header()
4254  {
4255  return m_header;
4256  }
4257 
4258  RTPS_DllAPI inline void element(
4259  const MinimalCollectionElement& _element)
4260  {
4261  m_element = _element;
4262  }
4263 
4264  RTPS_DllAPI inline void element(
4265  MinimalCollectionElement&& _element)
4266  {
4267  m_element = std::move(_element);
4268  }
4269 
4270  RTPS_DllAPI inline const MinimalCollectionElement& element() const
4271  {
4272  return m_element;
4273  }
4274 
4275  RTPS_DllAPI inline MinimalCollectionElement& element()
4276  {
4277  return m_element;
4278  }
4279 
4280 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4281  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::getCdrSerializedSize()",
4282  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4283  RTPS_DllAPI static size_t getCdrSerializedSize(
4284  const MinimalSequenceType& data,
4285  size_t current_alignment = 0);
4286  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::serialize()",
4287  "In favor of version using eprosima::fastcdr::serialize.")
4288  RTPS_DllAPI void serialize(
4289  eprosima::fastcdr::Cdr& cdr) const;
4290  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::deserialize()",
4291  "In favor of version using eprosima::fastcdr::deserialize.")
4292  RTPS_DllAPI void deserialize(
4293  eprosima::fastcdr::Cdr& cdr);
4294 #endif // DOXYGEN_SHOULD_SKIP_THIS
4295 
4296  RTPS_DllAPI bool operator ==(
4297  const MinimalSequenceType& other) const;
4298 
4299  RTPS_DllAPI bool consistent(
4300  const MinimalSequenceType& x,
4301  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4302 
4303 private:
4304 
4305  CollectionTypeFlag m_collection_flag;
4306  MinimalCollectionHeader m_header;
4307  MinimalCollectionElement m_element;
4308 };
4309 
4310 // --- Array: -----------------------------------------------------
4311 /*struct CommonArrayHeader final{
4312  LBoundSeq bound_seq;
4313  };*/
4315 {
4316 public:
4317 
4318  RTPS_DllAPI CommonArrayHeader();
4319  RTPS_DllAPI ~CommonArrayHeader();
4320  RTPS_DllAPI CommonArrayHeader(
4321  const CommonArrayHeader& x);
4322  RTPS_DllAPI CommonArrayHeader(
4323  CommonArrayHeader&& x);
4325  const CommonArrayHeader& x);
4327  CommonArrayHeader&& x);
4328 
4329  RTPS_DllAPI inline void bound_seq(
4330  const LBoundSeq& _bound_seq)
4331  {
4332  m_bound_seq = _bound_seq;
4333  }
4334 
4335  RTPS_DllAPI inline void bound_seq(
4336  LBoundSeq&& _bound_seq)
4337  {
4338  m_bound_seq = std::move(_bound_seq);
4339  }
4340 
4341  RTPS_DllAPI inline const LBoundSeq& bound_seq() const
4342  {
4343  return m_bound_seq;
4344  }
4345 
4346  RTPS_DllAPI inline LBoundSeq& bound_seq()
4347  {
4348  return m_bound_seq;
4349  }
4350 
4351 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4352  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::getCdrSerializedSize()",
4353  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4354  RTPS_DllAPI static size_t getCdrSerializedSize(
4355  const CommonArrayHeader& data,
4356  size_t current_alignment = 0);
4357  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::serialize()",
4358  "In favor of version using eprosima::fastcdr::serialize.")
4359  RTPS_DllAPI void serialize(
4360  eprosima::fastcdr::Cdr& cdr) const;
4361  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::deserialize()",
4362  "In favor of version using eprosima::fastcdr::deserialize.")
4363  RTPS_DllAPI void deserialize(
4364  eprosima::fastcdr::Cdr& cdr);
4365 #endif // DOXYGEN_SHOULD_SKIP_THIS
4366 
4367  RTPS_DllAPI bool operator ==(
4368  const CommonArrayHeader& other) const;
4369 
4370  RTPS_DllAPI bool consistent(
4371  const CommonArrayHeader& x,
4372  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4373 
4374 private:
4375 
4376  LBoundSeq m_bound_seq;
4377 };
4378 
4379 /*struct CompleteArrayHeader {
4380  CommonArrayHeader common;
4381  CompleteTypeDetail detail;
4382  };*/
4384 {
4385 public:
4386 
4387  RTPS_DllAPI CompleteArrayHeader();
4388  RTPS_DllAPI ~CompleteArrayHeader();
4389  RTPS_DllAPI CompleteArrayHeader(
4390  const CompleteArrayHeader& x);
4391  RTPS_DllAPI CompleteArrayHeader(
4392  CompleteArrayHeader&& x);
4394  const CompleteArrayHeader& x);
4396  CompleteArrayHeader&& x);
4397 
4398  RTPS_DllAPI inline void common(
4399  const CommonArrayHeader& _common)
4400  {
4401  m_common = _common;
4402  }
4403 
4404  RTPS_DllAPI inline void common(
4405  CommonArrayHeader&& _common)
4406  {
4407  m_common = std::move(_common);
4408  }
4409 
4410  RTPS_DllAPI inline const CommonArrayHeader& common() const
4411  {
4412  return m_common;
4413  }
4414 
4415  RTPS_DllAPI inline CommonArrayHeader& common()
4416  {
4417  return m_common;
4418  }
4419 
4420  RTPS_DllAPI inline void detail(
4421  const CompleteTypeDetail& _detail)
4422  {
4423  m_detail = _detail;
4424  }
4425 
4426  RTPS_DllAPI inline void detail(
4427  CompleteTypeDetail&& _detail)
4428  {
4429  m_detail = std::move(_detail);
4430  }
4431 
4432  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
4433  {
4434  return m_detail;
4435  }
4436 
4437  RTPS_DllAPI inline CompleteTypeDetail& detail()
4438  {
4439  return m_detail;
4440  }
4441 
4442 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4443  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::getCdrSerializedSize()",
4444  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4445  RTPS_DllAPI static size_t getCdrSerializedSize(
4446  const CompleteArrayHeader& data,
4447  size_t current_alignment = 0);
4448  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::serialize()",
4449  "In favor of version using eprosima::fastcdr::serialize.")
4450  RTPS_DllAPI void serialize(
4451  eprosima::fastcdr::Cdr& cdr) const;
4452  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::deserialize()",
4453  "In favor of version using eprosima::fastcdr::deserialize.")
4454  RTPS_DllAPI void deserialize(
4455  eprosima::fastcdr::Cdr& cdr);
4456 #endif // DOXYGEN_SHOULD_SKIP_THIS
4457 
4458  RTPS_DllAPI bool operator ==(
4459  const CompleteArrayHeader& other) const;
4460 
4461  RTPS_DllAPI bool consistent(
4462  const CompleteArrayHeader& x,
4463  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4464 
4465 private:
4466 
4467  CommonArrayHeader m_common;
4468  CompleteTypeDetail m_detail;
4469 };
4470 
4471 /*struct MinimalArrayHeader {
4472  CommonArrayHeader common;
4473  };*/
4475 {
4476 public:
4477 
4478  RTPS_DllAPI MinimalArrayHeader();
4479  RTPS_DllAPI ~MinimalArrayHeader();
4480  RTPS_DllAPI MinimalArrayHeader(
4481  const MinimalArrayHeader& x);
4482  RTPS_DllAPI MinimalArrayHeader(
4483  MinimalArrayHeader&& x);
4485  const MinimalArrayHeader& x);
4487  MinimalArrayHeader&& x);
4488 
4489  RTPS_DllAPI inline void common(
4490  const CommonArrayHeader& _common)
4491  {
4492  m_common = _common;
4493  }
4494 
4495  RTPS_DllAPI inline void common(
4496  CommonArrayHeader&& _common)
4497  {
4498  m_common = std::move(_common);
4499  }
4500 
4501  RTPS_DllAPI inline const CommonArrayHeader& common() const
4502  {
4503  return m_common;
4504  }
4505 
4506  RTPS_DllAPI inline CommonArrayHeader& common()
4507  {
4508  return m_common;
4509  }
4510 
4511 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4512  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::getCdrSerializedSize()",
4513  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4514  RTPS_DllAPI static size_t getCdrSerializedSize(
4515  const MinimalArrayHeader& data,
4516  size_t current_alignment = 0);
4517  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::serialize()",
4518  "In favor of version using eprosima::fastcdr::serialize.")
4519  RTPS_DllAPI void serialize(
4520  eprosima::fastcdr::Cdr& cdr) const;
4521  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::deserialize()",
4522  "In favor of version using eprosima::fastcdr::deserialize.")
4523  RTPS_DllAPI void deserialize(
4524  eprosima::fastcdr::Cdr& cdr);
4525 #endif // DOXYGEN_SHOULD_SKIP_THIS
4526 
4527  RTPS_DllAPI bool operator ==(
4528  const MinimalArrayHeader& other) const;
4529 
4530  RTPS_DllAPI bool consistent(
4531  const MinimalArrayHeader& x,
4532  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4533 
4534 private:
4535 
4536  CommonArrayHeader m_common;
4537 };
4538 
4539 /*struct CompleteArrayType {
4540  CollectionTypeFlag collection_flag;
4541  CompleteArrayHeader header;
4542  CompleteCollectionElement element;
4543  };*/
4545 {
4546 public:
4547 
4548  RTPS_DllAPI CompleteArrayType();
4549  RTPS_DllAPI ~CompleteArrayType();
4550  RTPS_DllAPI CompleteArrayType(
4551  const CompleteArrayType& x);
4552  RTPS_DllAPI CompleteArrayType(
4553  CompleteArrayType&& x);
4555  const CompleteArrayType& x);
4557  CompleteArrayType&& x);
4558 
4559  RTPS_DllAPI inline void collection_flag(
4560  const CollectionTypeFlag& _collection_flag)
4561  {
4562  m_collection_flag = _collection_flag;
4563  }
4564 
4565  RTPS_DllAPI inline void collection_flag(
4566  CollectionTypeFlag&& _collection_flag)
4567  {
4568  m_collection_flag = std::move(_collection_flag);
4569  }
4570 
4571  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4572  {
4573  return m_collection_flag;
4574  }
4575 
4576  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4577  {
4578  return m_collection_flag;
4579  }
4580 
4581  RTPS_DllAPI inline void header(
4582  const CompleteArrayHeader& _header)
4583  {
4584  m_header = _header;
4585  }
4586 
4587  RTPS_DllAPI inline void header(
4588  CompleteArrayHeader&& _header)
4589  {
4590  m_header = std::move(_header);
4591  }
4592 
4593  RTPS_DllAPI inline const CompleteArrayHeader& header() const
4594  {
4595  return m_header;
4596  }
4597 
4598  RTPS_DllAPI inline CompleteArrayHeader& header()
4599  {
4600  return m_header;
4601  }
4602 
4603  RTPS_DllAPI inline void element(
4604  const CompleteCollectionElement& _element)
4605  {
4606  m_element = _element;
4607  }
4608 
4609  RTPS_DllAPI inline void element(
4610  CompleteCollectionElement&& _element)
4611  {
4612  m_element = std::move(_element);
4613  }
4614 
4615  RTPS_DllAPI inline const CompleteCollectionElement& element() const
4616  {
4617  return m_element;
4618  }
4619 
4620  RTPS_DllAPI inline CompleteCollectionElement& element()
4621  {
4622  return m_element;
4623  }
4624 
4625 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4626  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::getCdrSerializedSize()",
4627  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4628  RTPS_DllAPI static size_t getCdrSerializedSize(
4629  const CompleteArrayType& data,
4630  size_t current_alignment = 0);
4631  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::serialize()",
4632  "In favor of version using eprosima::fastcdr::serialize.")
4633  RTPS_DllAPI void serialize(
4634  eprosima::fastcdr::Cdr& cdr) const;
4635  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::deserialize()",
4636  "In favor of version using eprosima::fastcdr::deserialize.")
4637  RTPS_DllAPI void deserialize(
4638  eprosima::fastcdr::Cdr& cdr);
4639 #endif // DOXYGEN_SHOULD_SKIP_THIS
4640 
4641  RTPS_DllAPI bool operator ==(
4642  const CompleteArrayType& other) const;
4643 
4644  RTPS_DllAPI bool consistent(
4645  const CompleteArrayType& x,
4646  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4647 
4648 private:
4649 
4650  CollectionTypeFlag m_collection_flag;
4651  CompleteArrayHeader m_header;
4652  CompleteCollectionElement m_element;
4653 };
4654 
4655 /*struct MinimalArrayType final{
4656  CollectionTypeFlag collection_flag;
4657  MinimalArrayHeader header;
4658  MinimalCollectionElement element;
4659  };*/
4661 {
4662 public:
4663 
4664  RTPS_DllAPI MinimalArrayType();
4665  RTPS_DllAPI ~MinimalArrayType();
4666  RTPS_DllAPI MinimalArrayType(
4667  const MinimalArrayType& x);
4668  RTPS_DllAPI MinimalArrayType(
4669  MinimalArrayType&& x);
4671  const MinimalArrayType& x);
4673  MinimalArrayType&& x);
4674 
4675  RTPS_DllAPI inline void collection_flag(
4676  const CollectionTypeFlag& _collection_flag)
4677  {
4678  m_collection_flag = _collection_flag;
4679  }
4680 
4681  RTPS_DllAPI inline void collection_flag(
4682  CollectionTypeFlag&& _collection_flag)
4683  {
4684  m_collection_flag = std::move(_collection_flag);
4685  }
4686 
4687  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4688  {
4689  return m_collection_flag;
4690  }
4691 
4692  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4693  {
4694  return m_collection_flag;
4695  }
4696 
4697  RTPS_DllAPI inline void header(
4698  const MinimalArrayHeader& _header)
4699  {
4700  m_header = _header;
4701  }
4702 
4703  RTPS_DllAPI inline void header(
4704  MinimalArrayHeader&& _header)
4705  {
4706  m_header = std::move(_header);
4707  }
4708 
4709  RTPS_DllAPI inline const MinimalArrayHeader& header() const
4710  {
4711  return m_header;
4712  }
4713 
4714  RTPS_DllAPI inline MinimalArrayHeader& header()
4715  {
4716  return m_header;
4717  }
4718 
4719  RTPS_DllAPI inline void element(
4720  const MinimalCollectionElement& _element)
4721  {
4722  m_element = _element;
4723  }
4724 
4725  RTPS_DllAPI inline void element(
4726  MinimalCollectionElement&& _element)
4727  {
4728  m_element = std::move(_element);
4729  }
4730 
4731  RTPS_DllAPI inline const MinimalCollectionElement& element() const
4732  {
4733  return m_element;
4734  }
4735 
4736  RTPS_DllAPI inline MinimalCollectionElement& element()
4737  {
4738  return m_element;
4739  }
4740 
4741 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4742  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::getCdrSerializedSize()",
4743  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4744  RTPS_DllAPI static size_t getCdrSerializedSize(
4745  const MinimalArrayType& data,
4746  size_t current_alignment = 0);
4747  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::serialize()",
4748  "In favor of version using eprosima::fastcdr::serialize.")
4749  RTPS_DllAPI void serialize(
4750  eprosima::fastcdr::Cdr& cdr) const;
4751  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::deserialize()",
4752  "In favor of version using eprosima::fastcdr::deserialize.")
4753  RTPS_DllAPI void deserialize(
4754  eprosima::fastcdr::Cdr& cdr);
4755 #endif // DOXYGEN_SHOULD_SKIP_THIS
4756 
4757  RTPS_DllAPI bool operator ==(
4758  const MinimalArrayType& other) const;
4759 
4760  RTPS_DllAPI bool consistent(
4761  const MinimalArrayType& x,
4762  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4763 
4764 private:
4765 
4766  CollectionTypeFlag m_collection_flag;
4767  MinimalArrayHeader m_header;
4768  MinimalCollectionElement m_element;
4769 };
4770 
4771 // --- Map: -----------------------------------------------------
4772 /*struct CompleteMapType final{
4773  CollectionTypeFlag collection_flag;
4774  CompleteCollectionHeader header;
4775  CompleteCollectionElement key;
4776  CompleteCollectionElement element;
4777  };*/
4778 class CompleteMapType final
4779 {
4780 public:
4781 
4782  RTPS_DllAPI CompleteMapType();
4783  RTPS_DllAPI ~CompleteMapType();
4784  RTPS_DllAPI CompleteMapType(
4785  const CompleteMapType& x);
4786  RTPS_DllAPI CompleteMapType(
4787  CompleteMapType&& x);
4789  const CompleteMapType& x);
4791  CompleteMapType&& x);
4792 
4793  RTPS_DllAPI inline void collection_flag(
4794  const CollectionTypeFlag& _collection_flag)
4795  {
4796  m_collection_flag = _collection_flag;
4797  }
4798 
4799  RTPS_DllAPI inline void collection_flag(
4800  CollectionTypeFlag&& _collection_flag)
4801  {
4802  m_collection_flag = std::move(_collection_flag);
4803  }
4804 
4805  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4806  {
4807  return m_collection_flag;
4808  }
4809 
4810  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4811  {
4812  return m_collection_flag;
4813  }
4814 
4815  RTPS_DllAPI inline void header(
4816  const CompleteCollectionHeader& _header)
4817  {
4818  m_header = _header;
4819  }
4820 
4821  RTPS_DllAPI inline void header(
4822  CompleteCollectionHeader&& _header)
4823  {
4824  m_header = std::move(_header);
4825  }
4826 
4827  RTPS_DllAPI inline const CompleteCollectionHeader& header() const
4828  {
4829  return m_header;
4830  }
4831 
4832  RTPS_DllAPI inline CompleteCollectionHeader& header()
4833  {
4834  return m_header;
4835  }
4836 
4837  RTPS_DllAPI inline void key(
4838  const CompleteCollectionElement& _key)
4839  {
4840  m_key = _key;
4841  }
4842 
4843  RTPS_DllAPI inline void key(
4845  {
4846  m_key = std::move(_key);
4847  }
4848 
4849  RTPS_DllAPI inline const CompleteCollectionElement& key() const
4850  {
4851  return m_key;
4852  }
4853 
4854  RTPS_DllAPI inline CompleteCollectionElement& key()
4855  {
4856  return m_key;
4857  }
4858 
4859  RTPS_DllAPI inline void element(
4860  const CompleteCollectionElement& _element)
4861  {
4862  m_element = _element;
4863  }
4864 
4865  RTPS_DllAPI inline void element(
4866  CompleteCollectionElement&& _element)
4867  {
4868  m_element = std::move(_element);
4869  }
4870 
4871  RTPS_DllAPI inline const CompleteCollectionElement& element() const
4872  {
4873  return m_element;
4874  }
4875 
4876  RTPS_DllAPI inline CompleteCollectionElement& element()
4877  {
4878  return m_element;
4879  }
4880 
4881 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4882  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::getCdrSerializedSize()",
4883  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4884  RTPS_DllAPI static size_t getCdrSerializedSize(
4885  const CompleteMapType& data,
4886  size_t current_alignment = 0);
4887  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::serialize()",
4888  "In favor of version using eprosima::fastcdr::serialize.")
4889  RTPS_DllAPI void serialize(
4890  eprosima::fastcdr::Cdr& cdr) const;
4891  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::deserialize()",
4892  "In favor of version using eprosima::fastcdr::deserialize.")
4893  RTPS_DllAPI void deserialize(
4894  eprosima::fastcdr::Cdr& cdr);
4895 #endif // DOXYGEN_SHOULD_SKIP_THIS
4896 
4897  RTPS_DllAPI bool operator ==(
4898  const CompleteMapType& other) const;
4899 
4900  RTPS_DllAPI bool consistent(
4901  const CompleteMapType& x,
4902  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4903 
4904 private:
4905 
4906  CollectionTypeFlag m_collection_flag;
4907  CompleteCollectionHeader m_header;
4909  CompleteCollectionElement m_element;
4910 };
4911 /*struct MinimalMapType final{
4912  CollectionTypeFlag collection_flag;
4913  MinimalCollectionHeader header;
4914  MinimalCollectionElement key;
4915  MinimalCollectionElement element;
4916  };*/
4917 class MinimalMapType final
4918 {
4919 public:
4920 
4921  RTPS_DllAPI MinimalMapType();
4922  RTPS_DllAPI ~MinimalMapType();
4923  RTPS_DllAPI MinimalMapType(
4924  const MinimalMapType& x);
4925  RTPS_DllAPI MinimalMapType(
4926  MinimalMapType&& x);
4928  const MinimalMapType& x);
4930  MinimalMapType&& x);
4931 
4932  RTPS_DllAPI inline void collection_flag(
4933  const CollectionTypeFlag& _collection_flag)
4934  {
4935  m_collection_flag = _collection_flag;
4936  }
4937 
4938  RTPS_DllAPI inline void collection_flag(
4939  CollectionTypeFlag&& _collection_flag)
4940  {
4941  m_collection_flag = std::move(_collection_flag);
4942  }
4943 
4944  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4945  {
4946  return m_collection_flag;
4947  }
4948 
4949  RTPS_DllAPI inline CollectionTypeFlag& collection_flag()
4950  {
4951  return m_collection_flag;
4952  }
4953 
4954  RTPS_DllAPI inline void header(
4955  const MinimalCollectionHeader& _header)
4956  {
4957  m_header = _header;
4958  }
4959 
4960  RTPS_DllAPI inline void header(
4961  MinimalCollectionHeader&& _header)
4962  {
4963  m_header = std::move(_header);
4964  }
4965 
4966  RTPS_DllAPI inline const MinimalCollectionHeader& header() const
4967  {
4968  return m_header;
4969  }
4970 
4971  RTPS_DllAPI inline MinimalCollectionHeader& header()
4972  {
4973  return m_header;
4974  }
4975 
4976  RTPS_DllAPI inline void key(
4977  const MinimalCollectionElement& _key)
4978  {
4979  m_key = _key;
4980  }
4981 
4982  RTPS_DllAPI inline void key(
4983  MinimalCollectionElement&& _key)
4984  {
4985  m_key = std::move(_key);
4986  }
4987 
4988  RTPS_DllAPI inline const MinimalCollectionElement& key() const
4989  {
4990  return m_key;
4991  }
4992 
4993  RTPS_DllAPI inline MinimalCollectionElement& key()
4994  {
4995  return m_key;
4996  }
4997 
4998  RTPS_DllAPI inline void element(
4999  const MinimalCollectionElement& _element)
5000  {
5001  m_element = _element;
5002  }
5003 
5004  RTPS_DllAPI inline void element(
5005  MinimalCollectionElement&& _element)
5006  {
5007  m_element = std::move(_element);
5008  }
5009 
5010  RTPS_DllAPI inline const MinimalCollectionElement& element() const
5011  {
5012  return m_element;
5013  }
5014 
5015  RTPS_DllAPI inline MinimalCollectionElement& element()
5016  {
5017  return m_element;
5018  }
5019 
5020 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5021  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::getCdrSerializedSize()",
5022  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5023  RTPS_DllAPI static size_t getCdrSerializedSize(
5024  const MinimalMapType& data,
5025  size_t current_alignment = 0);
5026  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::serialize()",
5027  "In favor of version using eprosima::fastcdr::serialize.")
5028  RTPS_DllAPI void serialize(
5029  eprosima::fastcdr::Cdr& cdr) const;
5030  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::deserialize()",
5031  "In favor of version using eprosima::fastcdr::deserialize.")
5032  RTPS_DllAPI void deserialize(
5033  eprosima::fastcdr::Cdr& cdr);
5034 #endif // DOXYGEN_SHOULD_SKIP_THIS
5035 
5036  RTPS_DllAPI bool operator ==(
5037  const MinimalMapType& other) const;
5038 
5039  RTPS_DllAPI bool consistent(
5040  const MinimalMapType& x,
5041  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5042 
5043 private:
5044 
5045  CollectionTypeFlag m_collection_flag;
5046  MinimalCollectionHeader m_header;
5048  MinimalCollectionElement m_element;
5049 };
5050 
5051 // --- Enumeration: ---------------------------------------------------
5052 typedef uint16_t BitBound;
5053 
5054 // Constant in an enumerated type
5055 
5056 /*struct CommonEnumeratedLiteral {
5057  int32_t value;
5058  EnumeratedLiteralFlag flags;
5059  };*/
5061 {
5062 public:
5063 
5067  const CommonEnumeratedLiteral& x);
5071  const CommonEnumeratedLiteral& x);
5074 
5075  RTPS_DllAPI inline void value(
5076  const int32_t& _value)
5077  {
5078  m_value = _value;
5079  }
5080 
5081  RTPS_DllAPI inline void value(
5082  int32_t&& _value)
5083  {
5084  m_value = std::move(_value);
5085  }
5086 
5087  RTPS_DllAPI inline const int32_t& value() const
5088  {
5089  return m_value;
5090  }
5091 
5092  RTPS_DllAPI inline int32_t& value()
5093  {
5094  return m_value;
5095  }
5096 
5097  RTPS_DllAPI inline void flags(
5098  const EnumeratedLiteralFlag& _flags)
5099  {
5100  m_flags = _flags;
5101  }
5102 
5103  RTPS_DllAPI inline void flags(
5104  EnumeratedLiteralFlag&& _flags)
5105  {
5106  m_flags = std::move(_flags);
5107  }
5108 
5109  RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const
5110  {
5111  return m_flags;
5112  }
5113 
5114  RTPS_DllAPI inline EnumeratedLiteralFlag& flags()
5115  {
5116  return m_flags;
5117  }
5118 
5119 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5120  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::getCdrSerializedSize()",
5121  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5122  RTPS_DllAPI static size_t getCdrSerializedSize(
5123  const CommonEnumeratedLiteral& data,
5124  size_t current_alignment = 0);
5125  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::serialize()",
5126  "In favor of version using eprosima::fastcdr::serialize.")
5127  RTPS_DllAPI void serialize(
5128  eprosima::fastcdr::Cdr& cdr) const;
5129  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::deserialize()",
5130  "In favor of version using eprosima::fastcdr::deserialize.")
5131  RTPS_DllAPI void deserialize(
5132  eprosima::fastcdr::Cdr& cdr);
5133 #endif // DOXYGEN_SHOULD_SKIP_THIS
5134 
5135  RTPS_DllAPI bool operator ==(
5136  const CommonEnumeratedLiteral& other) const;
5137 
5138  RTPS_DllAPI bool consistent(
5139  const CommonEnumeratedLiteral& x,
5140  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5141 
5142 private:
5143 
5144  int32_t m_value;
5145  EnumeratedLiteralFlag m_flags;
5146 };
5147 
5148 // Constant in an enumerated type
5149 
5150 /*struct CompleteEnumeratedLiteral {
5151  CommonEnumeratedLiteral common;
5152  CompleteMemberDetail detail;
5153  };*/
5155 {
5156 public:
5157 
5161  const CompleteEnumeratedLiteral& x);
5165  const CompleteEnumeratedLiteral& x);
5168 
5169  RTPS_DllAPI inline void common(
5170  const CommonEnumeratedLiteral& _common)
5171  {
5172  m_common = _common;
5173  }
5174 
5175  RTPS_DllAPI inline void common(
5176  CommonEnumeratedLiteral&& _common)
5177  {
5178  m_common = std::move(_common);
5179  }
5180 
5181  RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const
5182  {
5183  return m_common;
5184  }
5185 
5186  RTPS_DllAPI inline CommonEnumeratedLiteral& common()
5187  {
5188  return m_common;
5189  }
5190 
5191  RTPS_DllAPI inline void detail(
5192  const CompleteMemberDetail& _detail)
5193  {
5194  m_detail = _detail;
5195  }
5196 
5197  RTPS_DllAPI inline void detail(
5198  CompleteMemberDetail&& _detail)
5199  {
5200  m_detail = std::move(_detail);
5201  }
5202 
5203  RTPS_DllAPI inline const CompleteMemberDetail& detail() const
5204  {
5205  return m_detail;
5206  }
5207 
5208  RTPS_DllAPI inline CompleteMemberDetail& detail()
5209  {
5210  return m_detail;
5211  }
5212 
5213 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5214  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::getCdrSerializedSize()",
5215  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5216  RTPS_DllAPI static size_t getCdrSerializedSize(
5217  const CompleteEnumeratedLiteral& data,
5218  size_t current_alignment = 0);
5219  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::serialize()",
5220  "In favor of version using eprosima::fastcdr::serialize.")
5221  RTPS_DllAPI void serialize(
5222  eprosima::fastcdr::Cdr& cdr) const;
5223  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::deserialize()",
5224  "In favor of version using eprosima::fastcdr::deserialize.")
5225  RTPS_DllAPI void deserialize(
5226  eprosima::fastcdr::Cdr& cdr);
5227 #endif // DOXYGEN_SHOULD_SKIP_THIS
5228 
5229  RTPS_DllAPI bool operator ==(
5230  const CompleteEnumeratedLiteral& other) const;
5231 
5232  RTPS_DllAPI bool consistent(
5233  const CompleteEnumeratedLiteral& x,
5234  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5235 
5236 private:
5237 
5238  CommonEnumeratedLiteral m_common;
5239  CompleteMemberDetail m_detail;
5240 };
5241 // Ordered by EnumeratedLiteral.common.value
5242 typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
5243 
5244 // Constant in an enumerated type
5245 
5246 /*struct MinimalEnumeratedLiteral {
5247  CommonEnumeratedLiteral common;
5248  MinimalMemberDetail detail;
5249  };*/
5251 {
5252 public:
5253 
5257  const MinimalEnumeratedLiteral& x);
5261  const MinimalEnumeratedLiteral& x);
5264 
5265  RTPS_DllAPI inline void common(
5266  const CommonEnumeratedLiteral& _common)
5267  {
5268  m_common = _common;
5269  }
5270 
5271  RTPS_DllAPI inline void common(
5272  CommonEnumeratedLiteral&& _common)
5273  {
5274  m_common = std::move(_common);
5275  }
5276 
5277  RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const
5278  {
5279  return m_common;
5280  }
5281 
5282  RTPS_DllAPI inline CommonEnumeratedLiteral& common()
5283  {
5284  return m_common;
5285  }
5286 
5287  RTPS_DllAPI inline void detail(
5288  const MinimalMemberDetail& _detail)
5289  {
5290  m_detail = _detail;
5291  }
5292 
5293  RTPS_DllAPI inline void detail(
5294  MinimalMemberDetail&& _detail)
5295  {
5296  m_detail = std::move(_detail);
5297  }
5298 
5299  RTPS_DllAPI inline const MinimalMemberDetail& detail() const
5300  {
5301  return m_detail;
5302  }
5303 
5304  RTPS_DllAPI inline MinimalMemberDetail& detail()
5305  {
5306  return m_detail;
5307  }
5308 
5309 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5310  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::getCdrSerializedSize()",
5311  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5312  RTPS_DllAPI static size_t getCdrSerializedSize(
5313  const MinimalEnumeratedLiteral& data,
5314  size_t current_alignment = 0);
5315  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::serialize()",
5316  "In favor of version using eprosima::fastcdr::serialize.")
5317  RTPS_DllAPI void serialize(
5318  eprosima::fastcdr::Cdr& cdr) const;
5319  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::deserialize()",
5320  "In favor of version using eprosima::fastcdr::deserialize.")
5321  RTPS_DllAPI void deserialize(
5322  eprosima::fastcdr::Cdr& cdr);
5323 #endif // DOXYGEN_SHOULD_SKIP_THIS
5324 
5325  RTPS_DllAPI bool operator ==(
5326  const MinimalEnumeratedLiteral& other) const;
5327 
5328  RTPS_DllAPI bool consistent(
5329  const MinimalEnumeratedLiteral& x,
5330  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5331 
5332 private:
5333 
5334  CommonEnumeratedLiteral m_common;
5335  MinimalMemberDetail m_detail;
5336 };
5337 
5338 // Ordered by EnumeratedLiteral.common.value
5339 typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
5340 
5341 /*struct CommonEnumeratedHeader final{
5342  BitBound bit_bound;
5343  };*/
5345 {
5346 public:
5347 
5348  RTPS_DllAPI CommonEnumeratedHeader();
5351  const CommonEnumeratedHeader& x);
5355  const CommonEnumeratedHeader& x);
5358 
5359  RTPS_DllAPI inline void bit_bound(
5360  const BitBound& _bit_bound)
5361  {
5362  m_bit_bound = _bit_bound;
5363  }
5364 
5365  RTPS_DllAPI inline void bit_bound(
5366  BitBound&& _bit_bound)
5367  {
5368  m_bit_bound = std::move(_bit_bound);
5369  }
5370 
5371  RTPS_DllAPI inline const BitBound& bit_bound() const
5372  {
5373  return m_bit_bound;
5374  }
5375 
5376  RTPS_DllAPI inline BitBound& bit_bound()
5377  {
5378  return m_bit_bound;
5379  }
5380 
5381 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5382  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::getCdrSerializedSize()",
5383  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5384  RTPS_DllAPI static size_t getCdrSerializedSize(
5385  const CommonEnumeratedHeader& data,
5386  size_t current_alignment = 0);
5387  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::serialize()",
5388  "In favor of version using eprosima::fastcdr::serialize.")
5389  RTPS_DllAPI void serialize(
5390  eprosima::fastcdr::Cdr& cdr) const;
5391  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::deserialize()",
5392  "In favor of version using eprosima::fastcdr::deserialize.")
5393  RTPS_DllAPI void deserialize(
5394  eprosima::fastcdr::Cdr& cdr);
5395 #endif // DOXYGEN_SHOULD_SKIP_THIS
5396 
5397  RTPS_DllAPI bool operator ==(
5398  const CommonEnumeratedHeader& other) const;
5399 
5400  RTPS_DllAPI bool consistent(
5401  const CommonEnumeratedHeader& x,
5402  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5403 
5404 private:
5405 
5406  BitBound m_bit_bound;
5407 };
5408 
5409 /*struct CompleteEnumeratedHeader {
5410  CommonEnumeratedHeader common;
5411  CompleteTypeDetail detail;
5412  };*/
5414 {
5415 public:
5416 
5420  const CompleteEnumeratedHeader& x);
5424  const CompleteEnumeratedHeader& x);
5427 
5428  RTPS_DllAPI inline void common(
5429  const CommonEnumeratedHeader& _common)
5430  {
5431  m_common = _common;
5432  }
5433 
5434  RTPS_DllAPI inline void common(
5435  CommonEnumeratedHeader&& _common)
5436  {
5437  m_common = std::move(_common);
5438  }
5439 
5440  RTPS_DllAPI inline const CommonEnumeratedHeader& common() const
5441  {
5442  return m_common;
5443  }
5444 
5445  RTPS_DllAPI inline CommonEnumeratedHeader& common()
5446  {
5447  return m_common;
5448  }
5449 
5450  RTPS_DllAPI inline void detail(
5451  const CompleteTypeDetail& _detail)
5452  {
5453  m_detail = _detail;
5454  }
5455 
5456  RTPS_DllAPI inline void detail(
5457  CompleteTypeDetail&& _detail)
5458  {
5459  m_detail = std::move(_detail);
5460  }
5461 
5462  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
5463  {
5464  return m_detail;
5465  }
5466 
5467  RTPS_DllAPI inline CompleteTypeDetail& detail()
5468  {
5469  return m_detail;
5470  }
5471 
5472 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5473  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::getCdrSerializedSize()",
5474  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5475  RTPS_DllAPI static size_t getCdrSerializedSize(
5476  const CompleteEnumeratedHeader& data,
5477  size_t current_alignment = 0);
5478  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::serialize()",
5479  "In favor of version using eprosima::fastcdr::serialize.")
5480  RTPS_DllAPI void serialize(
5481  eprosima::fastcdr::Cdr& cdr) const;
5482  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::deserialize()",
5483  "In favor of version using eprosima::fastcdr::deserialize.")
5484  RTPS_DllAPI void deserialize(
5485  eprosima::fastcdr::Cdr& cdr);
5486 #endif // DOXYGEN_SHOULD_SKIP_THIS
5487 
5488  RTPS_DllAPI bool operator ==(
5489  const CompleteEnumeratedHeader& other) const;
5490 
5491  RTPS_DllAPI bool consistent(
5492  const CompleteEnumeratedHeader& x,
5493  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5494 
5495 private:
5496 
5497  CommonEnumeratedHeader m_common;
5498  CompleteTypeDetail m_detail;
5499 };
5500 
5501 /*struct MinimalEnumeratedHeader {
5502  CommonEnumeratedHeader common;
5503  };*/
5505 {
5506 public:
5507 
5511  const MinimalEnumeratedHeader& x);
5515  const MinimalEnumeratedHeader& x);
5518 
5519  RTPS_DllAPI inline void common(
5520  const CommonEnumeratedHeader& _common)
5521  {
5522  m_common = _common;
5523  }
5524 
5525  RTPS_DllAPI inline void common(
5526  CommonEnumeratedHeader&& _common)
5527  {
5528  m_common = std::move(_common);
5529  }
5530 
5531  RTPS_DllAPI inline const CommonEnumeratedHeader& common() const
5532  {
5533  return m_common;
5534  }
5535 
5536  RTPS_DllAPI inline CommonEnumeratedHeader& common()
5537  {
5538  return m_common;
5539  }
5540 
5541 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5542  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::getCdrSerializedSize()",
5543  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5544  RTPS_DllAPI static size_t getCdrSerializedSize(
5545  const MinimalEnumeratedHeader& data,
5546  size_t current_alignment = 0);
5547  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::serialize()",
5548  "In favor of version using eprosima::fastcdr::serialize.")
5549  RTPS_DllAPI void serialize(
5550  eprosima::fastcdr::Cdr& cdr) const;
5551  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::deserialize()",
5552  "In favor of version using eprosima::fastcdr::deserialize.")
5553  RTPS_DllAPI void deserialize(
5554  eprosima::fastcdr::Cdr& cdr);
5555 #endif // DOXYGEN_SHOULD_SKIP_THIS
5556 
5557  RTPS_DllAPI bool operator ==(
5558  const MinimalEnumeratedHeader& other) const;
5559 
5560  RTPS_DllAPI bool consistent(
5561  const MinimalEnumeratedHeader& x,
5562  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5563 
5564 private:
5565 
5566  CommonEnumeratedHeader m_common;
5567 };
5568 
5569 // Enumerated type
5570 /*struct CompleteEnumeratedType final{
5571  EnumTypeFlag enum_flags; // unused
5572  CompleteEnumeratedHeader header;
5573  CompleteEnumeratedLiteralSeq literal_seq;
5574  };*/
5576 {
5577 public:
5578 
5579  RTPS_DllAPI CompleteEnumeratedType();
5582  const CompleteEnumeratedType& x);
5586  const CompleteEnumeratedType& x);
5589 
5590  RTPS_DllAPI inline void enum_flags(
5591  const EnumTypeFlag& _enum_flags)
5592  {
5593  m_enum_flags = _enum_flags;
5594  }
5595 
5596  RTPS_DllAPI inline void enum_flags(
5597  EnumTypeFlag&& _enum_flags)
5598  {
5599  m_enum_flags = std::move(_enum_flags);
5600  }
5601 
5602  RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const
5603  {
5604  return m_enum_flags;
5605  }
5606 
5607  RTPS_DllAPI inline EnumTypeFlag& enum_flags()
5608  {
5609  return m_enum_flags;
5610  }
5611 
5612  RTPS_DllAPI inline void header(
5613  const CompleteEnumeratedHeader& _header)
5614  {
5615  m_header = _header;
5616  }
5617 
5618  RTPS_DllAPI inline void header(
5619  CompleteEnumeratedHeader&& _header)
5620  {
5621  m_header = std::move(_header);
5622  }
5623 
5624  RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const
5625  {
5626  return m_header;
5627  }
5628 
5629  RTPS_DllAPI inline CompleteEnumeratedHeader& header()
5630  {
5631  return m_header;
5632  }
5633 
5634  RTPS_DllAPI inline void literal_seq(
5635  const CompleteEnumeratedLiteralSeq& _literal_seq)
5636  {
5637  m_literal_seq = _literal_seq;
5638  }
5639 
5640  RTPS_DllAPI inline void literal_seq(
5641  CompleteEnumeratedLiteralSeq&& _literal_seq)
5642  {
5643  m_literal_seq = std::move(_literal_seq);
5644  }
5645 
5646  RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const
5647  {
5648  return m_literal_seq;
5649  }
5650 
5652  {
5653  return m_literal_seq;
5654  }
5655 
5656 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5657  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::getCdrSerializedSize()",
5658  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5659  RTPS_DllAPI static size_t getCdrSerializedSize(
5660  const CompleteEnumeratedType& data,
5661  size_t current_alignment = 0);
5662  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::serialize()",
5663  "In favor of version using eprosima::fastcdr::serialize.")
5664  RTPS_DllAPI void serialize(
5665  eprosima::fastcdr::Cdr& cdr) const;
5666  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::deserialize()",
5667  "In favor of version using eprosima::fastcdr::deserialize.")
5668  RTPS_DllAPI void deserialize(
5669  eprosima::fastcdr::Cdr& cdr);
5670 #endif // DOXYGEN_SHOULD_SKIP_THIS
5671 
5672  RTPS_DllAPI bool operator ==(
5673  const CompleteEnumeratedType& other) const;
5674 
5675  RTPS_DllAPI bool consistent(
5676  const CompleteEnumeratedType& x,
5677  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5678 
5679 private:
5680 
5681  EnumTypeFlag m_enum_flags;
5682  CompleteEnumeratedHeader m_header;
5683  CompleteEnumeratedLiteralSeq m_literal_seq;
5684 };
5685 // Enumerated type
5686 /*struct MinimalEnumeratedType final{
5687  EnumTypeFlag enum_flags; // unused
5688  MinimalEnumeratedHeader header;
5689  MinimalEnumeratedLiteralSeq literal_seq;
5690  };*/
5692 {
5693 public:
5694 
5695  RTPS_DllAPI MinimalEnumeratedType();
5696  RTPS_DllAPI ~MinimalEnumeratedType();
5698  const MinimalEnumeratedType& x);
5700  MinimalEnumeratedType&& x);
5702  const MinimalEnumeratedType& x);
5704  MinimalEnumeratedType&& x);
5705 
5706  RTPS_DllAPI inline void enum_flags(
5707  const EnumTypeFlag& _enum_flags)
5708  {
5709  m_enum_flags = _enum_flags;
5710  }
5711 
5712  RTPS_DllAPI inline void enum_flags(
5713  EnumTypeFlag&& _enum_flags)
5714  {
5715  m_enum_flags = std::move(_enum_flags);
5716  }
5717 
5718  RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const
5719  {
5720  return m_enum_flags;
5721  }
5722 
5723  RTPS_DllAPI inline EnumTypeFlag& enum_flags()
5724  {
5725  return m_enum_flags;
5726  }
5727 
5728  RTPS_DllAPI inline void header(
5729  const MinimalEnumeratedHeader& _header)
5730  {
5731  m_header = _header;
5732  }
5733 
5734  RTPS_DllAPI inline void header(
5735  MinimalEnumeratedHeader&& _header)
5736  {
5737  m_header = std::move(_header);
5738  }
5739 
5740  RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const
5741  {
5742  return m_header;
5743  }
5744 
5745  RTPS_DllAPI inline MinimalEnumeratedHeader& header()
5746  {
5747  return m_header;
5748  }
5749 
5750  RTPS_DllAPI inline void literal_seq(
5751  const MinimalEnumeratedLiteralSeq& _literal_seq)
5752  {
5753  m_literal_seq = _literal_seq;
5754  }
5755 
5756  RTPS_DllAPI inline void literal_seq(
5757  MinimalEnumeratedLiteralSeq&& _literal_seq)
5758  {
5759  m_literal_seq = std::move(_literal_seq);
5760  }
5761 
5762  RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const
5763  {
5764  return m_literal_seq;
5765  }
5766 
5768  {
5769  return m_literal_seq;
5770  }
5771 
5772 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5773  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::getCdrSerializedSize()",
5774  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5775  RTPS_DllAPI static size_t getCdrSerializedSize(
5776  const MinimalEnumeratedType& data,
5777  size_t current_alignment = 0);
5778  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::serialize()",
5779  "In favor of version using eprosima::fastcdr::serialize.")
5780  RTPS_DllAPI void serialize(
5781  eprosima::fastcdr::Cdr& cdr) const;
5782  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::deserialize()",
5783  "In favor of version using eprosima::fastcdr::deserialize.")
5784  RTPS_DllAPI void deserialize(
5785  eprosima::fastcdr::Cdr& cdr);
5786 #endif // DOXYGEN_SHOULD_SKIP_THIS
5787 
5788  RTPS_DllAPI bool operator ==(
5789  const MinimalEnumeratedType& other) const;
5790 
5791  RTPS_DllAPI bool consistent(
5792  const MinimalEnumeratedType& x,
5793  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5794 
5795 private:
5796 
5797  EnumTypeFlag m_enum_flags;
5798  MinimalEnumeratedHeader m_header;
5799  MinimalEnumeratedLiteralSeq m_literal_seq;
5800 };
5801 
5802 // --- Bitmask: -------------------------------------------------------
5803 // Bit in a bit mask
5804 /*struct CommonBitflag final{
5805  uint16_t position;
5806  BitflagFlag flags;
5807  };*/
5808 class CommonBitflag final
5809 {
5810 public:
5811 
5812  RTPS_DllAPI CommonBitflag();
5813  RTPS_DllAPI ~CommonBitflag();
5814  RTPS_DllAPI CommonBitflag(
5815  const CommonBitflag& x);
5816  RTPS_DllAPI CommonBitflag(
5817  CommonBitflag&& x);
5819  const CommonBitflag& x);
5821  CommonBitflag&& x);
5822 
5823  RTPS_DllAPI inline void position(
5824  const uint16_t& _position)
5825  {
5826  m_position = _position;
5827  }
5828 
5829  RTPS_DllAPI inline void position(
5830  uint16_t&& _position)
5831  {
5832  m_position = std::move(_position);
5833  }
5834 
5835  RTPS_DllAPI inline const uint16_t& position() const
5836  {
5837  return m_position;
5838  }
5839 
5840  RTPS_DllAPI inline uint16_t& position()
5841  {
5842  return m_position;
5843  }
5844 
5845  RTPS_DllAPI inline void flags(
5846  const BitflagFlag& _flags)
5847  {
5848  m_flags = _flags;
5849  }
5850 
5851  RTPS_DllAPI inline void flags(
5852  BitflagFlag&& _flags)
5853  {
5854  m_flags = std::move(_flags);
5855  }
5856 
5857  RTPS_DllAPI inline const BitflagFlag& flags() const
5858  {
5859  return m_flags;
5860  }
5861 
5862  RTPS_DllAPI inline BitflagFlag& flags()
5863  {
5864  return m_flags;
5865  }
5866 
5867 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5868  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::getCdrSerializedSize()",
5869  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5870  RTPS_DllAPI static size_t getCdrSerializedSize(
5871  const CommonBitflag& data,
5872  size_t current_alignment = 0);
5873  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::serialize()",
5874  "In favor of version using eprosima::fastcdr::serialize.")
5875  RTPS_DllAPI void serialize(
5876  eprosima::fastcdr::Cdr& cdr) const;
5877  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::deserialize()",
5878  "In favor of version using eprosima::fastcdr::deserialize.")
5879  RTPS_DllAPI void deserialize(
5880  eprosima::fastcdr::Cdr& cdr);
5881 #endif // DOXYGEN_SHOULD_SKIP_THIS
5882 
5883  RTPS_DllAPI bool operator ==(
5884  const CommonBitflag& other) const;
5885 
5886  RTPS_DllAPI bool consistent(
5887  const CommonBitflag& x,
5888  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5889 
5890 private:
5891 
5892  uint16_t m_position;
5893  BitflagFlag m_flags;
5894 };
5895 
5896 /*struct CompleteBitflag {
5897  CommonBitflag common;
5898  CompleteMemberDetail detail;
5899  };*/
5901 {
5902 public:
5903 
5904  RTPS_DllAPI CompleteBitflag();
5905  RTPS_DllAPI ~CompleteBitflag();
5906  RTPS_DllAPI CompleteBitflag(
5907  const CompleteBitflag& x);
5908  RTPS_DllAPI CompleteBitflag(
5909  CompleteBitflag&& x);
5911  const CompleteBitflag& x);
5913  CompleteBitflag&& x);
5914 
5915  RTPS_DllAPI inline void common(
5916  const CommonBitflag& _common)
5917  {
5918  m_common = _common;
5919  }
5920 
5921  RTPS_DllAPI inline void common(
5922  CommonBitflag&& _common)
5923  {
5924  m_common = std::move(_common);
5925  }
5926 
5927  RTPS_DllAPI inline const CommonBitflag& common() const
5928  {
5929  return m_common;
5930  }
5931 
5932  RTPS_DllAPI inline CommonBitflag& common()
5933  {
5934  return m_common;
5935  }
5936 
5937  RTPS_DllAPI inline void detail(
5938  const CompleteMemberDetail& _detail)
5939  {
5940  m_detail = _detail;
5941  }
5942 
5943  RTPS_DllAPI inline void detail(
5944  CompleteMemberDetail&& _detail)
5945  {
5946  m_detail = std::move(_detail);
5947  }
5948 
5949  RTPS_DllAPI inline const CompleteMemberDetail& detail() const
5950  {
5951  return m_detail;
5952  }
5953 
5954  RTPS_DllAPI inline CompleteMemberDetail& detail()
5955  {
5956  return m_detail;
5957  }
5958 
5959 #ifndef DOXYGEN_SHOULD_SKIP_THIS
5960  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::getCdrSerializedSize()",
5961  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5962  RTPS_DllAPI static size_t getCdrSerializedSize(
5963  const CompleteBitflag& data,
5964  size_t current_alignment = 0);
5965  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::serialize()",
5966  "In favor of version using eprosima::fastcdr::serialize.")
5967  RTPS_DllAPI void serialize(
5968  eprosima::fastcdr::Cdr& cdr) const;
5969  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::deserialize()",
5970  "In favor of version using eprosima::fastcdr::deserialize.")
5971  RTPS_DllAPI void deserialize(
5972  eprosima::fastcdr::Cdr& cdr);
5973 #endif // DOXYGEN_SHOULD_SKIP_THIS
5974 
5975  RTPS_DllAPI bool operator ==(
5976  const CompleteBitflag& other) const;
5977 
5978  RTPS_DllAPI bool consistent(
5979  const CompleteBitflag& x,
5980  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5981 
5982 private:
5983 
5984  CommonBitflag m_common;
5985  CompleteMemberDetail m_detail;
5986 };
5987 // Ordered by Bitflag.position
5988 typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
5989 /*struct MinimalBitflag {
5990  CommonBitflag common;
5991  MinimalMemberDetail detail;
5992  };*/
5994 {
5995 public:
5996 
5997  RTPS_DllAPI MinimalBitflag();
5998  RTPS_DllAPI ~MinimalBitflag();
5999  RTPS_DllAPI MinimalBitflag(
6000  const MinimalBitflag& x);
6001  RTPS_DllAPI MinimalBitflag(
6002  MinimalBitflag&& x);
6004  const MinimalBitflag& x);
6006  MinimalBitflag&& x);
6007 
6008  RTPS_DllAPI inline void common(
6009  const CommonBitflag& _common)
6010  {
6011  m_common = _common;
6012  }
6013 
6014  RTPS_DllAPI inline void common(
6015  CommonBitflag&& _common)
6016  {
6017  m_common = std::move(_common);
6018  }
6019 
6020  RTPS_DllAPI inline const CommonBitflag& common() const
6021  {
6022  return m_common;
6023  }
6024 
6025  RTPS_DllAPI inline CommonBitflag& common()
6026  {
6027  return m_common;
6028  }
6029 
6030  RTPS_DllAPI inline void detail(
6031  const MinimalMemberDetail& _detail)
6032  {
6033  m_detail = _detail;
6034  }
6035 
6036  RTPS_DllAPI inline void detail(
6037  MinimalMemberDetail&& _detail)
6038  {
6039  m_detail = std::move(_detail);
6040  }
6041 
6042  RTPS_DllAPI inline const MinimalMemberDetail& detail() const
6043  {
6044  return m_detail;
6045  }
6046 
6047  RTPS_DllAPI inline MinimalMemberDetail& detail()
6048  {
6049  return m_detail;
6050  }
6051 
6052 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6053  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::getCdrSerializedSize()",
6054  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6055  RTPS_DllAPI static size_t getCdrSerializedSize(
6056  const MinimalBitflag& data,
6057  size_t current_alignment = 0);
6058  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::serialize()",
6059  "In favor of version using eprosima::fastcdr::serialize.")
6060  RTPS_DllAPI void serialize(
6061  eprosima::fastcdr::Cdr& cdr) const;
6062  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::deserialize()",
6063  "In favor of version using eprosima::fastcdr::deserialize.")
6064  RTPS_DllAPI void deserialize(
6065  eprosima::fastcdr::Cdr& cdr);
6066 #endif // DOXYGEN_SHOULD_SKIP_THIS
6067 
6068  RTPS_DllAPI bool operator ==(
6069  const MinimalBitflag& other) const;
6070 
6071  RTPS_DllAPI bool consistent(
6072  const MinimalBitflag& x,
6073  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6074 
6075 private:
6076 
6077  CommonBitflag m_common;
6078  MinimalMemberDetail m_detail;
6079 };
6080 
6081 // Ordered by Bitflag.position
6082 typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
6083 
6084 /*struct CommonBitmaskHeader final{
6085  BitBound bit_bound;
6086  };*/
6088 {
6089 public:
6090 
6091  RTPS_DllAPI CommonBitmaskHeader();
6092  RTPS_DllAPI ~CommonBitmaskHeader();
6093  RTPS_DllAPI CommonBitmaskHeader(
6094  const CommonBitmaskHeader& x);
6095  RTPS_DllAPI CommonBitmaskHeader(
6096  CommonBitmaskHeader&& x);
6098  const CommonBitmaskHeader& x);
6100  CommonBitmaskHeader&& x);
6101 
6102  RTPS_DllAPI inline void bit_bound(
6103  const BitBound& _bit_bound)
6104  {
6105  m_bit_bound = _bit_bound;
6106  }
6107 
6108  RTPS_DllAPI inline void bit_bound(
6109  BitBound&& _bit_bound)
6110  {
6111  m_bit_bound = std::move(_bit_bound);
6112  }
6113 
6114  RTPS_DllAPI inline const BitBound& bit_bound() const
6115  {
6116  return m_bit_bound;
6117  }
6118 
6119  RTPS_DllAPI inline BitBound& bit_bound()
6120  {
6121  return m_bit_bound;
6122  }
6123 
6124 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6125  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::getCdrSerializedSize()",
6126  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6127  RTPS_DllAPI static size_t getCdrSerializedSize(
6128  const CommonBitmaskHeader& data,
6129  size_t current_alignment = 0);
6130  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::serialize()",
6131  "In favor of version using eprosima::fastcdr::serialize.")
6132  RTPS_DllAPI void serialize(
6133  eprosima::fastcdr::Cdr& cdr) const;
6134  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::deserialize()",
6135  "In favor of version using eprosima::fastcdr::deserialize.")
6136  RTPS_DllAPI void deserialize(
6137  eprosima::fastcdr::Cdr& cdr);
6138 #endif // DOXYGEN_SHOULD_SKIP_THIS
6139 
6140  RTPS_DllAPI bool operator ==(
6141  const CommonBitmaskHeader& other) const;
6142 
6143  RTPS_DllAPI bool consistent(
6144  const CommonBitmaskHeader& x,
6145  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6146 
6147 private:
6148 
6149  BitBound m_bit_bound;
6150 };
6152 
6154 /*struct CompleteBitmaskType {
6155  BitmaskTypeFlag bitmask_flags; // unused
6156  CompleteBitmaskHeader header;
6157  CompleteBitflagSeq flag_seq;
6158  };*/
6160 {
6161 public:
6162 
6163  RTPS_DllAPI CompleteBitmaskType();
6164  RTPS_DllAPI ~CompleteBitmaskType();
6165  RTPS_DllAPI CompleteBitmaskType(
6166  const CompleteBitmaskType& x);
6167  RTPS_DllAPI CompleteBitmaskType(
6168  CompleteBitmaskType&& x);
6170  const CompleteBitmaskType& x);
6172  CompleteBitmaskType&& x);
6173 
6174  RTPS_DllAPI inline void bitmask_flags(
6175  const BitmaskTypeFlag& _bitmask_flags)
6176  {
6177  m_bitmask_flags = _bitmask_flags;
6178  }
6179 
6180  RTPS_DllAPI inline void bitmask_flags(
6181  BitmaskTypeFlag&& _bitmask_flags)
6182  {
6183  m_bitmask_flags = std::move(_bitmask_flags);
6184  }
6185 
6186  RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const
6187  {
6188  return m_bitmask_flags;
6189  }
6190 
6191  RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags()
6192  {
6193  return m_bitmask_flags;
6194  }
6195 
6196  RTPS_DllAPI inline void header(
6197  const CompleteBitmaskHeader& _header)
6198  {
6199  m_header = _header;
6200  }
6201 
6202  RTPS_DllAPI inline void header(
6203  CompleteBitmaskHeader&& _header)
6204  {
6205  m_header = std::move(_header);
6206  }
6207 
6208  RTPS_DllAPI inline const CompleteBitmaskHeader& header() const
6209  {
6210  return m_header;
6211  }
6212 
6213  RTPS_DllAPI inline CompleteBitmaskHeader& header()
6214  {
6215  return m_header;
6216  }
6217 
6218  RTPS_DllAPI inline void flag_seq(
6219  const CompleteBitflagSeq& _flag_seq)
6220  {
6221  m_flag_seq = _flag_seq;
6222  }
6223 
6224  RTPS_DllAPI inline void flag_seq(
6225  CompleteBitflagSeq&& _flag_seq)
6226  {
6227  m_flag_seq = std::move(_flag_seq);
6228  }
6229 
6230  RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const
6231  {
6232  return m_flag_seq;
6233  }
6234 
6235  RTPS_DllAPI inline CompleteBitflagSeq& flag_seq()
6236  {
6237  return m_flag_seq;
6238  }
6239 
6240 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6241  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::getCdrSerializedSize()",
6242  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6243  RTPS_DllAPI static size_t getCdrSerializedSize(
6244  const CompleteBitmaskType& data,
6245  size_t current_alignment = 0);
6246  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::serialize()",
6247  "In favor of version using eprosima::fastcdr::serialize.")
6248  RTPS_DllAPI void serialize(
6249  eprosima::fastcdr::Cdr& cdr) const;
6250  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::deserialize()",
6251  "In favor of version using eprosima::fastcdr::deserialize.")
6252  RTPS_DllAPI void deserialize(
6253  eprosima::fastcdr::Cdr& cdr);
6254 #endif // DOXYGEN_SHOULD_SKIP_THIS
6255 
6256  RTPS_DllAPI bool operator ==(
6257  const CompleteBitmaskType& other) const;
6258 
6259  RTPS_DllAPI bool consistent(
6260  const CompleteBitmaskType& x,
6261  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6262 
6263 private:
6264 
6265  BitmaskTypeFlag m_bitmask_flags;
6266  CompleteBitmaskHeader m_header;
6267  CompleteBitflagSeq m_flag_seq;
6268 };
6269 
6270 /*struct MinimalBitmaskType {
6271  BitmaskTypeFlag bitmask_flags; // unused
6272  MinimalBitmaskHeader header;
6273  MinimalBitflagSeq flag_seq;
6274  };*/
6276 {
6277 public:
6278 
6279  RTPS_DllAPI MinimalBitmaskType();
6280  RTPS_DllAPI ~MinimalBitmaskType();
6281  RTPS_DllAPI MinimalBitmaskType(
6282  const MinimalBitmaskType& x);
6283  RTPS_DllAPI MinimalBitmaskType(
6284  MinimalBitmaskType&& x);
6286  const MinimalBitmaskType& x);
6288  MinimalBitmaskType&& x);
6289 
6290  RTPS_DllAPI inline void bitmask_flags(
6291  const BitmaskTypeFlag& _bitmask_flags)
6292  {
6293  m_bitmask_flags = _bitmask_flags;
6294  }
6295 
6296  RTPS_DllAPI inline void bitmask_flags(
6297  BitmaskTypeFlag&& _bitmask_flags)
6298  {
6299  m_bitmask_flags = std::move(_bitmask_flags);
6300  }
6301 
6302  RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const
6303  {
6304  return m_bitmask_flags;
6305  }
6306 
6307  RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags()
6308  {
6309  return m_bitmask_flags;
6310  }
6311 
6312  RTPS_DllAPI inline void header(
6313  const MinimalBitmaskHeader& _header)
6314  {
6315  m_header = _header;
6316  }
6317 
6318  RTPS_DllAPI inline void header(
6319  MinimalBitmaskHeader&& _header)
6320  {
6321  m_header = std::move(_header);
6322  }
6323 
6324  RTPS_DllAPI inline const MinimalBitmaskHeader& header() const
6325  {
6326  return m_header;
6327  }
6328 
6329  RTPS_DllAPI inline MinimalBitmaskHeader& header()
6330  {
6331  return m_header;
6332  }
6333 
6334  RTPS_DllAPI inline void flag_seq(
6335  const MinimalBitflagSeq& _flag_seq)
6336  {
6337  m_flag_seq = _flag_seq;
6338  }
6339 
6340  RTPS_DllAPI inline void flag_seq(
6341  MinimalBitflagSeq&& _flag_seq)
6342  {
6343  m_flag_seq = std::move(_flag_seq);
6344  }
6345 
6346  RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const
6347  {
6348  return m_flag_seq;
6349  }
6350 
6351  RTPS_DllAPI inline MinimalBitflagSeq& flag_seq()
6352  {
6353  return m_flag_seq;
6354  }
6355 
6356 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6357  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::getCdrSerializedSize()",
6358  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6359  RTPS_DllAPI static size_t getCdrSerializedSize(
6360  const MinimalBitmaskType& data,
6361  size_t current_alignment = 0);
6362  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::serialize()",
6363  "In favor of version using eprosima::fastcdr::serialize.")
6364  RTPS_DllAPI void serialize(
6365  eprosima::fastcdr::Cdr& cdr) const;
6366  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::deserialize()",
6367  "In favor of version using eprosima::fastcdr::deserialize.")
6368  RTPS_DllAPI void deserialize(
6369  eprosima::fastcdr::Cdr& cdr);
6370 #endif // DOXYGEN_SHOULD_SKIP_THIS
6371 
6372  RTPS_DllAPI bool operator ==(
6373  const MinimalBitmaskType& other) const;
6374 
6375  RTPS_DllAPI bool consistent(
6376  const MinimalBitmaskType& x,
6377  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6378 
6379 private:
6380 
6381  BitmaskTypeFlag m_bitmask_flags;
6382  MinimalBitmaskHeader m_header;
6383  MinimalBitflagSeq m_flag_seq;
6384 };
6385 
6386 // --- Bitset: ---------------------------------------------------------
6387 /*struct CommonBitfield final{
6388  uint16_t position;
6389  BitsetMemberFlag flags;
6390  octet bitcount;
6391  TypeKind holder_type; // Must be primitive integer type
6392  };*/
6393 class CommonBitfield final
6394 {
6395 public:
6396 
6397  RTPS_DllAPI CommonBitfield();
6398  RTPS_DllAPI ~CommonBitfield();
6399  RTPS_DllAPI CommonBitfield(
6400  const CommonBitfield& x);
6401  RTPS_DllAPI CommonBitfield(
6402  CommonBitfield&& x);
6404  const CommonBitfield& x);
6406  CommonBitfield&& x);
6407 
6408  RTPS_DllAPI inline void position(
6409  const uint16_t& _position)
6410  {
6411  m_position = _position;
6412  }
6413 
6414  RTPS_DllAPI inline void position(
6415  uint16_t&& _position)
6416  {
6417  m_position = std::move(_position);
6418  }
6419 
6420  RTPS_DllAPI inline const uint16_t& position() const
6421  {
6422  return m_position;
6423  }
6424 
6425  RTPS_DllAPI inline uint16_t& position()
6426  {
6427  return m_position;
6428  }
6429 
6430  RTPS_DllAPI inline void flags(
6431  const BitsetMemberFlag& _flags)
6432  {
6433  m_flags = _flags;
6434  }
6435 
6436  RTPS_DllAPI inline void flags(
6437  BitsetMemberFlag&& _flags)
6438  {
6439  m_flags = std::move(_flags);
6440  }
6441 
6442  RTPS_DllAPI inline const BitsetMemberFlag& flags() const
6443  {
6444  return m_flags;
6445  }
6446 
6447  RTPS_DllAPI inline BitsetMemberFlag& flags()
6448  {
6449  return m_flags;
6450  }
6451 
6452  RTPS_DllAPI inline void bitcount(
6453  const octet& _bitcount)
6454  {
6455  m_bitcount = _bitcount;
6456  }
6457 
6458  RTPS_DllAPI inline void bitcount(
6459  octet&& _bitcount)
6460  {
6461  m_bitcount = std::move(_bitcount);
6462  }
6463 
6464  RTPS_DllAPI inline const octet& bitcount() const
6465  {
6466  return m_bitcount;
6467  }
6468 
6469  RTPS_DllAPI inline octet& bitcount()
6470  {
6471  return m_bitcount;
6472  }
6473 
6474  RTPS_DllAPI inline void holder_type(
6475  const TypeKind& _holder_type)
6476  {
6477  m_holder_type = _holder_type;
6478  }
6479 
6480  RTPS_DllAPI inline void holder_type(
6481  TypeKind&& _holder_type)
6482  {
6483  m_holder_type = std::move(_holder_type);
6484  }
6485 
6486  RTPS_DllAPI inline const TypeKind& holder_type() const
6487  {
6488  return m_holder_type;
6489  }
6490 
6491  RTPS_DllAPI inline TypeKind& holder_type()
6492  {
6493  return m_holder_type;
6494  }
6495 
6496 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6497  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::getCdrSerializedSize()",
6498  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6499  RTPS_DllAPI static size_t getCdrSerializedSize(
6500  const CommonBitfield& data,
6501  size_t current_alignment = 0);
6502  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::serialize()",
6503  "In favor of version using eprosima::fastcdr::serialize.")
6504  RTPS_DllAPI void serialize(
6505  eprosima::fastcdr::Cdr& cdr) const;
6506  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::deserialize()",
6507  "In favor of version using eprosima::fastcdr::deserialize.")
6508  RTPS_DllAPI void deserialize(
6509  eprosima::fastcdr::Cdr& cdr);
6510 #endif // DOXYGEN_SHOULD_SKIP_THIS
6511 
6512  RTPS_DllAPI bool operator ==(
6513  const CommonBitfield& other) const;
6514 
6515  RTPS_DllAPI bool consistent(
6516  const CommonBitfield& x,
6517  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6518 
6519 private:
6520 
6521  uint16_t m_position;
6522  BitsetMemberFlag m_flags;
6523  octet m_bitcount;
6524  TypeKind m_holder_type;
6525 };
6526 
6527 /*struct CompleteBitfield {
6528  CommonBitfield common;
6529  CompleteMemberDetail detail;
6530  };*/
6532 {
6533 public:
6534 
6535  RTPS_DllAPI CompleteBitfield();
6536  RTPS_DllAPI ~CompleteBitfield();
6537  RTPS_DllAPI CompleteBitfield(
6538  const CompleteBitfield& x);
6539  RTPS_DllAPI CompleteBitfield(
6540  CompleteBitfield&& x);
6542  const CompleteBitfield& x);
6544  CompleteBitfield&& x);
6545 
6546  RTPS_DllAPI inline void common(
6547  const CommonBitfield& _common)
6548  {
6549  m_common = _common;
6550  }
6551 
6552  RTPS_DllAPI inline void common(
6553  CommonBitfield&& _common)
6554  {
6555  m_common = std::move(_common);
6556  }
6557 
6558  RTPS_DllAPI inline const CommonBitfield& common() const
6559  {
6560  return m_common;
6561  }
6562 
6563  RTPS_DllAPI inline CommonBitfield& common()
6564  {
6565  return m_common;
6566  }
6567 
6568  RTPS_DllAPI inline void detail(
6569  const CompleteMemberDetail& _detail)
6570  {
6571  m_detail = _detail;
6572  }
6573 
6574  RTPS_DllAPI inline void detail(
6575  CompleteMemberDetail&& _detail)
6576  {
6577  m_detail = std::move(_detail);
6578  }
6579 
6580  RTPS_DllAPI inline const CompleteMemberDetail& detail() const
6581  {
6582  return m_detail;
6583  }
6584 
6585  RTPS_DllAPI inline CompleteMemberDetail& detail()
6586  {
6587  return m_detail;
6588  }
6589 
6590 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6591  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfield::getCdrSerializedSize()",
6592  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6593  RTPS_DllAPI static size_t getCdrSerializedSize(
6594  const CompleteBitfield& data,
6595  size_t current_alignment = 0);
6596  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfield::serialize()",
6597  "In favor of version using eprosima::fastcdr::serialize.")
6598  RTPS_DllAPI void serialize(
6599  eprosima::fastcdr::Cdr& cdr) const;
6600  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfielddeserialize()",
6601  "In favor of version using eprosima::fastcdr::deserialize.")
6602  RTPS_DllAPI void deserialize(
6603  eprosima::fastcdr::Cdr& cdr);
6604 #endif // DOXYGEN_SHOULD_SKIP_THIS
6605 
6606  RTPS_DllAPI bool operator ==(
6607  const CompleteBitfield& other) const;
6608 
6609  RTPS_DllAPI bool consistent(
6610  const CompleteBitfield& x,
6611  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6612 
6613 private:
6614 
6615  CommonBitfield m_common;
6616  CompleteMemberDetail m_detail;
6617 };
6618 // Ordered by Bitfield.position
6619 typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
6620 /*struct MinimalBitfield {
6621  CommonBitfield common;
6622  NameHash name_hash;
6623  };*/
6625 {
6626 public:
6627 
6628  RTPS_DllAPI MinimalBitfield();
6629  RTPS_DllAPI ~MinimalBitfield();
6630  RTPS_DllAPI MinimalBitfield(
6631  const MinimalBitfield& x);
6632  RTPS_DllAPI MinimalBitfield(
6633  MinimalBitfield&& x);
6635  const MinimalBitfield& x);
6637  MinimalBitfield&& x);
6638 
6639  RTPS_DllAPI inline void name_hash(
6640  const NameHash& _name_hash)
6641  {
6642  m_name_hash = _name_hash;
6643  }
6644 
6645  RTPS_DllAPI inline void name_hash(
6646  NameHash&& _name_hash)
6647  {
6648  m_name_hash = std::move(_name_hash);
6649  }
6650 
6651  RTPS_DllAPI inline const NameHash& name_hash() const
6652  {
6653  return m_name_hash;
6654  }
6655 
6656  RTPS_DllAPI inline NameHash& name_hash()
6657  {
6658  return m_name_hash;
6659  }
6660 
6661  RTPS_DllAPI inline void common(
6662  const CommonBitfield& _common)
6663  {
6664  m_common = _common;
6665  }
6666 
6667  RTPS_DllAPI inline void common(
6668  CommonBitfield&& _common)
6669  {
6670  m_common = std::move(_common);
6671  }
6672 
6673  RTPS_DllAPI inline const CommonBitfield& common() const
6674  {
6675  return m_common;
6676  }
6677 
6678  RTPS_DllAPI inline CommonBitfield& common()
6679  {
6680  return m_common;
6681  }
6682 
6683 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6684  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::getCdrSerializedSize()",
6685  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6686  RTPS_DllAPI static size_t getCdrSerializedSize(
6687  const MinimalBitfield& data,
6688  size_t current_alignment = 0);
6689  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::serialize()",
6690  "In favor of version using eprosima::fastcdr::serialize.")
6691  RTPS_DllAPI void serialize(
6692  eprosima::fastcdr::Cdr& cdr) const;
6693  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::deserialize()",
6694  "In favor of version using eprosima::fastcdr::deserialize.")
6695  RTPS_DllAPI void deserialize(
6696  eprosima::fastcdr::Cdr& cdr);
6697 #endif // DOXYGEN_SHOULD_SKIP_THIS
6698 
6699  RTPS_DllAPI bool operator ==(
6700  const MinimalBitfield& other) const;
6701 
6702  RTPS_DllAPI bool consistent(
6703  const MinimalBitfield& x,
6704  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6705 
6706 private:
6707 
6708  CommonBitfield m_common;
6709  NameHash m_name_hash;
6710 };
6711 // Ordered by Bitfield.position
6712 typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
6713 /*struct CompleteBitsetHeader {
6714  CompleteTypeDetail detail;
6715  };*/
6717 {
6718 public:
6719 
6720  RTPS_DllAPI CompleteBitsetHeader();
6721  RTPS_DllAPI ~CompleteBitsetHeader();
6723  const CompleteBitsetHeader& x);
6725  CompleteBitsetHeader&& x);
6727  const CompleteBitsetHeader& x);
6729  CompleteBitsetHeader&& x);
6730 
6731  RTPS_DllAPI inline void base_type(
6732  const TypeIdentifier& _base_type)
6733  {
6734  m_base_type = _base_type;
6735  }
6736 
6737  RTPS_DllAPI inline void base_type(
6738  TypeIdentifier&& _base_type)
6739  {
6740  m_base_type = std::move(_base_type);
6741  }
6742 
6743  RTPS_DllAPI inline const TypeIdentifier& base_type() const
6744  {
6745  return m_base_type;
6746  }
6747 
6748  RTPS_DllAPI inline TypeIdentifier& base_type()
6749  {
6750  return m_base_type;
6751  }
6752 
6753  RTPS_DllAPI inline void detail(
6754  const CompleteTypeDetail& _detail)
6755  {
6756  m_detail = _detail;
6757  }
6758 
6759  RTPS_DllAPI inline void detail(
6760  CompleteTypeDetail&& _detail)
6761  {
6762  m_detail = std::move(_detail);
6763  }
6764 
6765  RTPS_DllAPI inline const CompleteTypeDetail& detail() const
6766  {
6767  return m_detail;
6768  }
6769 
6770  RTPS_DllAPI inline CompleteTypeDetail& detail()
6771  {
6772  return m_detail;
6773  }
6774 
6775 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6776  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::getCdrSerializedSize()",
6777  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6778  RTPS_DllAPI static size_t getCdrSerializedSize(
6779  const CompleteBitsetHeader& data,
6780  size_t current_alignment = 0);
6781  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::serialize()",
6782  "In favor of version using eprosima::fastcdr::serialize.")
6783  RTPS_DllAPI void serialize(
6784  eprosima::fastcdr::Cdr& cdr) const;
6785  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::deserialize()",
6786  "In favor of version using eprosima::fastcdr::deserialize.")
6787  RTPS_DllAPI void deserialize(
6788  eprosima::fastcdr::Cdr& cdr);
6789 #endif // DOXYGEN_SHOULD_SKIP_THIS
6790 
6791  RTPS_DllAPI bool operator ==(
6792  const CompleteBitsetHeader& other) const;
6793 
6794  RTPS_DllAPI bool consistent(
6795  const CompleteBitsetHeader& x,
6796  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6797 
6798 private:
6799 
6800  TypeIdentifier m_base_type;
6801  CompleteTypeDetail m_detail;
6802 };
6803 
6804 /*struct MinimalBitsetHeader {
6805  // Empty. Available for future extension
6806  };*/
6808 {
6809 public:
6810 
6811  RTPS_DllAPI MinimalBitsetHeader();
6812  RTPS_DllAPI ~MinimalBitsetHeader();
6813  RTPS_DllAPI MinimalBitsetHeader(
6814  const MinimalBitsetHeader& x);
6815  RTPS_DllAPI MinimalBitsetHeader(
6816  MinimalBitsetHeader&& x);
6818  const MinimalBitsetHeader& x);
6820  MinimalBitsetHeader&& x);
6821 
6822  RTPS_DllAPI inline void base_type(
6823  const TypeIdentifier& _base_type)
6824  {
6825  m_base_type = _base_type;
6826  }
6827 
6828  RTPS_DllAPI inline void base_type(
6829  TypeIdentifier&& _base_type)
6830  {
6831  m_base_type = std::move(_base_type);
6832  }
6833 
6834  RTPS_DllAPI inline const TypeIdentifier& base_type() const
6835  {
6836  return m_base_type;
6837  }
6838 
6839  RTPS_DllAPI inline TypeIdentifier& base_type()
6840  {
6841  return m_base_type;
6842  }
6843 
6844 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6845  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::getCdrSerializedSize()",
6846  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6847  RTPS_DllAPI static size_t getCdrSerializedSize(
6848  const MinimalBitsetHeader& data,
6849  size_t current_alignment = 0);
6850  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::serialize()",
6851  "In favor of version using eprosima::fastcdr::serialize.")
6852  RTPS_DllAPI void serialize(
6853  eprosima::fastcdr::Cdr& cdr) const;
6854  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::deserialize()",
6855  "In favor of version using eprosima::fastcdr::deserialize.")
6856  RTPS_DllAPI void deserialize(
6857  eprosima::fastcdr::Cdr& cdr);
6858 #endif // DOXYGEN_SHOULD_SKIP_THIS
6859 
6860  RTPS_DllAPI bool operator ==(
6861  const MinimalBitsetHeader& other) const;
6862 
6863  RTPS_DllAPI bool consistent(
6864  const MinimalBitsetHeader& x,
6865  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6866 
6867 private:
6868 
6869  TypeIdentifier m_base_type;
6870 };
6871 /*struct CompleteBitsetType {
6872  BitsetTypeFlag bitset_flags; // unused
6873  CompleteBitsetHeader header;
6874  CompleteBitfieldSeq field_seq;
6875  };*/
6877 {
6878 public:
6879 
6880  RTPS_DllAPI CompleteBitsetType();
6881  RTPS_DllAPI ~CompleteBitsetType();
6882  RTPS_DllAPI CompleteBitsetType(
6883  const CompleteBitsetType& x);
6884  RTPS_DllAPI CompleteBitsetType(
6885  CompleteBitsetType&& x);
6887  const CompleteBitsetType& x);
6889  CompleteBitsetType&& x);
6890 
6891  RTPS_DllAPI inline void bitset_flags(
6892  const BitsetTypeFlag& _bitset_flags)
6893  {
6894  m_bitset_flags = _bitset_flags;
6895  }
6896 
6897  RTPS_DllAPI inline void bitset_flags(
6898  BitsetTypeFlag&& _bitset_flags)
6899  {
6900  m_bitset_flags = std::move(_bitset_flags);
6901  }
6902 
6903  RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const
6904  {
6905  return m_bitset_flags;
6906  }
6907 
6908  RTPS_DllAPI inline BitsetTypeFlag& bitset_flags()
6909  {
6910  return m_bitset_flags;
6911  }
6912 
6913  RTPS_DllAPI inline void header(
6914  const CompleteBitsetHeader& _header)
6915  {
6916  m_header = _header;
6917  }
6918 
6919  RTPS_DllAPI inline void header(
6920  CompleteBitsetHeader&& _header)
6921  {
6922  m_header = std::move(_header);
6923  }
6924 
6925  RTPS_DllAPI inline const CompleteBitsetHeader& header() const
6926  {
6927  return m_header;
6928  }
6929 
6930  RTPS_DllAPI inline CompleteBitsetHeader& header()
6931  {
6932  return m_header;
6933  }
6934 
6935  RTPS_DllAPI inline void field_seq(
6936  const CompleteBitfieldSeq& _field_seq)
6937  {
6938  m_field_seq = _field_seq;
6939  }
6940 
6941  RTPS_DllAPI inline void field_seq(
6942  CompleteBitfieldSeq&& _field_seq)
6943  {
6944  m_field_seq = std::move(_field_seq);
6945  }
6946 
6947  RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const
6948  {
6949  return m_field_seq;
6950  }
6951 
6952  RTPS_DllAPI inline CompleteBitfieldSeq& field_seq()
6953  {
6954  return m_field_seq;
6955  }
6956 
6957 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6958  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::getCdrSerializedSize()",
6959  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6960  RTPS_DllAPI static size_t getCdrSerializedSize(
6961  const CompleteBitsetType& data,
6962  size_t current_alignment = 0);
6963  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::serialize()",
6964  "In favor of version using eprosima::fastcdr::serialize.")
6965  RTPS_DllAPI void serialize(
6966  eprosima::fastcdr::Cdr& cdr) const;
6967  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::deserialize()",
6968  "In favor of version using eprosima::fastcdr::deserialize.")
6969  RTPS_DllAPI void deserialize(
6970  eprosima::fastcdr::Cdr& cdr);
6971 #endif // DOXYGEN_SHOULD_SKIP_THIS
6972 
6973  RTPS_DllAPI bool operator ==(
6974  const CompleteBitsetType& other) const;
6975 
6976  RTPS_DllAPI bool consistent(
6977  const CompleteBitsetType& x,
6978  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6979 
6980 private:
6981 
6982  BitsetTypeFlag m_bitset_flags;
6983  CompleteBitsetHeader m_header;
6984  CompleteBitfieldSeq m_field_seq;
6985 };
6986 
6987 /*struct MinimalBitsetType {
6988  BitsetTypeFlag bitset_flags; // unused
6989  MinimalBitsetHeader header;
6990  MinimalBitfieldSeq field_seq;
6991  };*/
6993 {
6994 public:
6995 
6996  RTPS_DllAPI MinimalBitsetType();
6997  RTPS_DllAPI ~MinimalBitsetType();
6998  RTPS_DllAPI MinimalBitsetType(
6999  const MinimalBitsetType& x);
7000  RTPS_DllAPI MinimalBitsetType(
7001  MinimalBitsetType&& x);
7003  const MinimalBitsetType& x);
7005  MinimalBitsetType&& x);
7006 
7007  RTPS_DllAPI inline void bitset_flags(
7008  const BitsetTypeFlag& _bitset_flags)
7009  {
7010  m_bitset_flags = _bitset_flags;
7011  }
7012 
7013  RTPS_DllAPI inline void bitset_flags(
7014  BitsetTypeFlag&& _bitset_flags)
7015  {
7016  m_bitset_flags = std::move(_bitset_flags);
7017  }
7018 
7019  RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const
7020  {
7021  return m_bitset_flags;
7022  }
7023 
7024  RTPS_DllAPI inline BitsetTypeFlag& bitset_flags()
7025  {
7026  return m_bitset_flags;
7027  }
7028 
7029  RTPS_DllAPI inline void header(
7030  const MinimalBitsetHeader& _header)
7031  {
7032  m_header = _header;
7033  }
7034 
7035  RTPS_DllAPI inline void header(
7036  MinimalBitsetHeader&& _header)
7037  {
7038  m_header = std::move(_header);
7039  }
7040 
7041  RTPS_DllAPI inline const MinimalBitsetHeader& header() const
7042  {
7043  return m_header;
7044  }
7045 
7046  RTPS_DllAPI inline MinimalBitsetHeader& header()
7047  {
7048  return m_header;
7049  }
7050 
7051  RTPS_DllAPI inline void field_seq(
7052  const MinimalBitfieldSeq& _field_seq)
7053  {
7054  m_field_seq = _field_seq;
7055  }
7056 
7057  RTPS_DllAPI inline void field_seq(
7058  MinimalBitfieldSeq&& _field_seq)
7059  {
7060  m_field_seq = std::move(_field_seq);
7061  }
7062 
7063  RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const
7064  {
7065  return m_field_seq;
7066  }
7067 
7068  RTPS_DllAPI inline MinimalBitfieldSeq& field_seq()
7069  {
7070  return m_field_seq;
7071  }
7072 
7073 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7074  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::getCdrSerializedSize()",
7075  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7076  RTPS_DllAPI static size_t getCdrSerializedSize(
7077  const MinimalBitsetType& data,
7078  size_t current_alignment = 0);
7079  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::serialize()",
7080  "In favor of version using eprosima::fastcdr::serialize.")
7081  RTPS_DllAPI void serialize(
7082  eprosima::fastcdr::Cdr& cdr) const;
7083  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::deserialize()",
7084  "In favor of version using eprosima::fastcdr::deserialize.")
7085  RTPS_DllAPI void deserialize(
7086  eprosima::fastcdr::Cdr& cdr);
7087 #endif // DOXYGEN_SHOULD_SKIP_THIS
7088 
7089  RTPS_DllAPI bool operator ==(
7090  const MinimalBitsetType& other) const;
7091 
7092  RTPS_DllAPI bool consistent(
7093  const MinimalBitsetType& x,
7094  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7095 
7096 private:
7097 
7098  BitsetTypeFlag m_bitset_flags;
7099  MinimalBitsetHeader m_header;
7100  MinimalBitfieldSeq m_field_seq;
7101 };
7102 
7103 // --- Type Object: --------------------------------------------------
7104 // The types associated with each case selection must have extensibility
7105 // kind APPENDABLE or MUTABLE so that they can be extended in the future
7106 
7107 /*struct CompleteExtendedType {
7108  // Empty. Available for future extension
7109  };*/
7111 {
7112 public:
7113 
7114  RTPS_DllAPI CompleteExtendedType();
7115  RTPS_DllAPI ~CompleteExtendedType();
7117  const CompleteExtendedType& x);
7119  CompleteExtendedType&& x);
7121  const CompleteExtendedType& x);
7123  CompleteExtendedType&& x);
7124 
7125 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7126  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::getCdrSerializedSize()",
7127  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7128  RTPS_DllAPI static size_t getCdrSerializedSize(
7129  const CompleteExtendedType& data,
7130  size_t current_alignment = 0);
7131  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::serialize()",
7132  "In favor of version using eprosima::fastcdr::serialize.")
7133  RTPS_DllAPI void serialize(
7134  eprosima::fastcdr::Cdr& cdr) const;
7135  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::deserialize()",
7136  "In favor of version using eprosima::fastcdr::deserialize.")
7137  RTPS_DllAPI void deserialize(
7138  eprosima::fastcdr::Cdr& cdr);
7139 #endif // DOXYGEN_SHOULD_SKIP_THIS
7140 
7141  RTPS_DllAPI bool operator ==(
7142  const CompleteExtendedType&) const
7143  {
7144  return true;
7145  }
7146 
7147  RTPS_DllAPI bool consistent(
7148  const CompleteExtendedType& x,
7149  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7150 
7151 private:
7152 
7153 };
7154 
7155 /*struct MinimalExtendedType {
7156  // Empty. Available for future extension
7157  };*/
7159 {
7160 public:
7161 
7162  RTPS_DllAPI MinimalExtendedType();
7163  RTPS_DllAPI ~MinimalExtendedType();
7164  RTPS_DllAPI MinimalExtendedType(
7165  const MinimalExtendedType& x);
7166  RTPS_DllAPI MinimalExtendedType(
7167  MinimalExtendedType&& x);
7169  const MinimalExtendedType& x);
7171  MinimalExtendedType&& x);
7172 
7173 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7174  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::getCdrSerializedSize()",
7175  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7176  RTPS_DllAPI static size_t getCdrSerializedSize(
7177  const MinimalExtendedType& data,
7178  size_t current_alignment = 0);
7179  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::serialize()",
7180  "In favor of version using eprosima::fastcdr::serialize.")
7181  RTPS_DllAPI void serialize(
7182  eprosima::fastcdr::Cdr& cdr) const;
7183  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::deserialize()",
7184  "In favor of version using eprosima::fastcdr::deserialize.")
7185  RTPS_DllAPI void deserialize(
7186  eprosima::fastcdr::Cdr& cdr);
7187 #endif // DOXYGEN_SHOULD_SKIP_THIS
7188 
7189  RTPS_DllAPI bool operator ==(
7190  const MinimalExtendedType&) const
7191  {
7192  return true;
7193  }
7194 
7195  RTPS_DllAPI bool consistent(
7196  const MinimalExtendedType& x,
7197  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7198 
7199 private:
7200 
7201 };
7202 
7204 {
7205 public:
7206 
7207  RTPS_DllAPI CompleteTypeObject();
7208  RTPS_DllAPI ~CompleteTypeObject();
7209  RTPS_DllAPI CompleteTypeObject(
7210  const CompleteTypeObject& x);
7211  RTPS_DllAPI CompleteTypeObject(
7212  CompleteTypeObject&& x);
7214  const CompleteTypeObject& x);
7216  CompleteTypeObject&& x);
7217  RTPS_DllAPI void _d(
7218  octet __d);
7219  RTPS_DllAPI octet _d() const;
7220  RTPS_DllAPI octet& _d();
7221 
7222  RTPS_DllAPI void alias_type(
7223  CompleteAliasType _alias_type);
7224  RTPS_DllAPI const CompleteAliasType& alias_type() const;
7226 
7227  RTPS_DllAPI void annotation_type(
7228  CompleteAnnotationType _annotation_type);
7229  RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;
7231 
7232  RTPS_DllAPI void struct_type(
7233  CompleteStructType _struct_type);
7234  RTPS_DllAPI const CompleteStructType& struct_type() const;
7236 
7237  RTPS_DllAPI void union_type(
7238  CompleteUnionType _union_type);
7239  RTPS_DllAPI const CompleteUnionType& union_type() const;
7241 
7242  RTPS_DllAPI void bitset_type(
7243  CompleteBitsetType _bitset_type);
7244  RTPS_DllAPI const CompleteBitsetType& bitset_type() const;
7246 
7247  RTPS_DllAPI void sequence_type(
7248  CompleteSequenceType _sequence_type);
7249  RTPS_DllAPI const CompleteSequenceType& sequence_type() const;
7251 
7252  RTPS_DllAPI void array_type(
7253  CompleteArrayType _array_type);
7254  RTPS_DllAPI const CompleteArrayType& array_type() const;
7256 
7257  RTPS_DllAPI void map_type(
7258  CompleteMapType _map_type);
7259  RTPS_DllAPI const CompleteMapType& map_type() const;
7260  RTPS_DllAPI CompleteMapType& map_type();
7261 
7262  RTPS_DllAPI void enumerated_type(
7263  CompleteEnumeratedType _enumerated_type);
7264  RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;
7266 
7267  RTPS_DllAPI void bitmask_type(
7268  CompleteBitmaskType _bitmask_type);
7269  RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;
7271 
7272  RTPS_DllAPI void extended_type(
7273  CompleteExtendedType _extended_type);
7274  RTPS_DllAPI const CompleteExtendedType& extended_type() const;
7276 
7277 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7278  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::getCdrSerializedSize()",
7279  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7280  RTPS_DllAPI static size_t getCdrSerializedSize(
7281  const CompleteTypeObject& data,
7282  size_t current_alignment = 0);
7283  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::serialize()",
7284  "In favor of version using eprosima::fastcdr::serialize.")
7285  RTPS_DllAPI void serialize(
7286  eprosima::fastcdr::Cdr& cdr) const;
7287  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::deserialize()",
7288  "In favor of version using eprosima::fastcdr::deserialize.")
7289  RTPS_DllAPI void deserialize(
7290  eprosima::fastcdr::Cdr& cdr);
7291 #endif // DOXYGEN_SHOULD_SKIP_THIS
7292 
7293  RTPS_DllAPI bool operator ==(
7294  const CompleteTypeObject& other) const;
7295 
7296  RTPS_DllAPI bool consistent(
7297  const CompleteTypeObject& x,
7298  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7299 
7300 private:
7301 
7302  octet m__d;
7303 
7304  CompleteAliasType m_alias_type;
7305  CompleteAnnotationType m_annotation_type;
7306  CompleteStructType m_struct_type;
7307  CompleteUnionType m_union_type;
7308  CompleteBitsetType m_bitset_type;
7309  CompleteSequenceType m_sequence_type;
7310  CompleteArrayType m_array_type;
7311  CompleteMapType m_map_type;
7312  CompleteEnumeratedType m_enumerated_type;
7313  CompleteBitmaskType m_bitmask_type;
7314  CompleteExtendedType m_extended_type;
7315 };
7316 
7318 {
7319 public:
7320 
7321  RTPS_DllAPI MinimalTypeObject();
7322  RTPS_DllAPI ~MinimalTypeObject();
7323  RTPS_DllAPI MinimalTypeObject(
7324  const MinimalTypeObject& x);
7325  RTPS_DllAPI MinimalTypeObject(
7326  MinimalTypeObject&& x);
7328  const MinimalTypeObject& x);
7330  MinimalTypeObject&& x);
7331  RTPS_DllAPI void _d(
7332  octet __d);
7333  RTPS_DllAPI octet _d() const;
7334  RTPS_DllAPI octet& _d();
7335 
7336  RTPS_DllAPI void alias_type(
7337  MinimalAliasType _alias_type);
7338  RTPS_DllAPI const MinimalAliasType& alias_type() const;
7340 
7341  RTPS_DllAPI void annotation_type(
7342  MinimalAnnotationType _annotation_type);
7343  RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;
7345 
7346  RTPS_DllAPI void struct_type(
7347  MinimalStructType _struct_type);
7348  RTPS_DllAPI const MinimalStructType& struct_type() const;
7350 
7351  RTPS_DllAPI void union_type(
7352  MinimalUnionType _union_type);
7353  RTPS_DllAPI const MinimalUnionType& union_type() const;
7355 
7356  RTPS_DllAPI void bitset_type(
7357  MinimalBitsetType _bitset_type);
7358  RTPS_DllAPI const MinimalBitsetType& bitset_type() const;
7360 
7361  RTPS_DllAPI void sequence_type(
7362  MinimalSequenceType _sequence_type);
7363  RTPS_DllAPI const MinimalSequenceType& sequence_type() const;
7365 
7366  RTPS_DllAPI void array_type(
7367  MinimalArrayType _array_type);
7368  RTPS_DllAPI const MinimalArrayType& array_type() const;
7370 
7371  RTPS_DllAPI void map_type(
7372  MinimalMapType _map_type);
7373  RTPS_DllAPI const MinimalMapType& map_type() const;
7374  RTPS_DllAPI MinimalMapType& map_type();
7375 
7376  RTPS_DllAPI void enumerated_type(
7377  MinimalEnumeratedType _enumerated_type);
7378  RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;
7380 
7381  RTPS_DllAPI void bitmask_type(
7382  MinimalBitmaskType _bitmask_type);
7383  RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;
7385 
7386  RTPS_DllAPI void extended_type(
7387  MinimalExtendedType _extended_type);
7388  RTPS_DllAPI const MinimalExtendedType& extended_type() const;
7390 
7391 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7392  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::getCdrSerializedSize()",
7393  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7394  RTPS_DllAPI static size_t getCdrSerializedSize(
7395  const MinimalTypeObject& data,
7396  size_t current_alignment = 0);
7397  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::serialize()",
7398  "In favor of version using eprosima::fastcdr::serialize.")
7399  RTPS_DllAPI void serialize(
7400  eprosima::fastcdr::Cdr& cdr) const;
7401  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::deserialize()",
7402  "In favor of version using eprosima::fastcdr::deserialize.")
7403  RTPS_DllAPI void deserialize(
7404  eprosima::fastcdr::Cdr& cdr);
7405 #endif // DOXYGEN_SHOULD_SKIP_THIS
7406 
7407  RTPS_DllAPI bool operator ==(
7408  const MinimalTypeObject& other) const;
7409 
7410  RTPS_DllAPI bool consistent(
7411  const MinimalTypeObject& x,
7412  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7413 
7414 private:
7415 
7416  octet m__d;
7417 
7418  MinimalAliasType m_alias_type;
7419  MinimalAnnotationType m_annotation_type;
7420  MinimalStructType m_struct_type;
7421  MinimalUnionType m_union_type;
7422  MinimalBitsetType m_bitset_type;
7423  MinimalSequenceType m_sequence_type;
7424  MinimalArrayType m_array_type;
7425  MinimalMapType m_map_type;
7426  MinimalEnumeratedType m_enumerated_type;
7427  MinimalBitmaskType m_bitmask_type;
7428  MinimalExtendedType m_extended_type;
7429 };
7431 {
7432 public:
7433 
7437  RTPS_DllAPI TypeObject();
7438 
7442  RTPS_DllAPI ~TypeObject();
7443 
7448  RTPS_DllAPI TypeObject(
7449  const TypeObject& x);
7450 
7455  RTPS_DllAPI TypeObject(
7456  TypeObject&& x);
7457 
7462  RTPS_DllAPI TypeObject& operator =(
7463  const TypeObject& x);
7464 
7469  RTPS_DllAPI TypeObject& operator =(
7470  TypeObject&& x);
7471 
7477  RTPS_DllAPI void _d(
7478  uint8_t __d);
7479 
7484  RTPS_DllAPI uint8_t _d() const;
7485 
7490  RTPS_DllAPI uint8_t& _d();
7491 
7496  RTPS_DllAPI void complete(
7497  const CompleteTypeObject& _complete);
7498 
7503  RTPS_DllAPI void complete(
7504  CompleteTypeObject&& _complete);
7505 
7511  RTPS_DllAPI const CompleteTypeObject& complete() const;
7512 
7523  RTPS_DllAPI void minimal(
7524  const MinimalTypeObject& _minimal);
7525 
7530  RTPS_DllAPI void minimal(
7531  MinimalTypeObject&& _minimal);
7532 
7538  RTPS_DllAPI const MinimalTypeObject& minimal() const;
7539 
7545  RTPS_DllAPI MinimalTypeObject& minimal();
7546 
7547 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7554  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::getCdrSerializedSize()",
7555  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7556  RTPS_DllAPI static size_t getCdrSerializedSize(
7557  const TypeObject& data,
7558  size_t current_alignment = 0);
7563  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::serialize()",
7564  "In favor of version using eprosima::fastcdr::serialize.")
7565  RTPS_DllAPI void serialize(
7566  eprosima::fastcdr::Cdr& cdr) const;
7567 
7572  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::deserialize()",
7573  "In favor of version using eprosima::fastcdr::deserialize.")
7574  RTPS_DllAPI void deserialize(
7575  eprosima::fastcdr::Cdr& cdr);
7576 #endif // DOXYGEN_SHOULD_SKIP_THIS
7577 
7578  RTPS_DllAPI bool operator ==(
7579  const TypeObject& other) const;
7580 
7586  RTPS_DllAPI bool consistent(
7587  const TypeObject& x,
7588  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7589 
7590 private:
7591 
7592  uint8_t m__d;
7593 
7594  CompleteTypeObject m_complete;
7595  MinimalTypeObject m_minimal;
7596 };
7597 
7598 typedef std::vector<TypeObject> TypeObjectSeq;
7599 
7600 // Set of TypeObjects representing a strong component: Equivalence class
7601 // for the Strong Connectivity relationship (mutual reachability between
7602 // types).
7603 // Ordered by fully qualified typename lexicographic order
7605 
7606 /*struct TypeIdentifierTypeObjectPair final {
7607  TypeIdentifier type_identifier;
7608  TypeObject type_object;
7609  };*/
7611 {
7612 public:
7613 
7617  const TypeIdentifierTypeObjectPair& x);
7621  const TypeIdentifierTypeObjectPair& x);
7624 
7625  RTPS_DllAPI inline void type_identifier(
7626  const TypeIdentifier& _type_identifier)
7627  {
7628  m_type_identifier = _type_identifier;
7629  }
7630 
7631  RTPS_DllAPI inline void type_identifier(
7632  TypeIdentifier&& _type_identifier)
7633  {
7634  m_type_identifier = std::move(_type_identifier);
7635  }
7636 
7637  RTPS_DllAPI inline const TypeIdentifier& type_identifier() const
7638  {
7639  return m_type_identifier;
7640  }
7641 
7642  RTPS_DllAPI inline TypeIdentifier& type_identifier()
7643  {
7644  return m_type_identifier;
7645  }
7646 
7647  RTPS_DllAPI inline void type_object(
7648  const TypeObject& _type_object)
7649  {
7650  m_type_object = _type_object;
7651  }
7652 
7653  RTPS_DllAPI inline void type_object(
7654  TypeObject&& _type_object)
7655  {
7656  m_type_object = std::move(_type_object);
7657  }
7658 
7659  RTPS_DllAPI inline const TypeObject& type_object() const
7660  {
7661  return m_type_object;
7662  }
7663 
7664  RTPS_DllAPI inline TypeObject& type_object()
7665  {
7666  return m_type_object;
7667  }
7668 
7669 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7670  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::getCdrSerializedSize()",
7671  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7672  RTPS_DllAPI static size_t getCdrSerializedSize(
7673  const TypeIdentifierTypeObjectPair& data,
7674  size_t current_alignment = 0);
7675  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::serialize()",
7676  "In favor of version using eprosima::fastcdr::serialize.")
7677  RTPS_DllAPI void serialize(
7678  eprosima::fastcdr::Cdr& cdr) const;
7679  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::deserialize()",
7680  "In favor of version using eprosima::fastcdr::deserialize.")
7681  RTPS_DllAPI void deserialize(
7682  eprosima::fastcdr::Cdr& cdr);
7683 #endif // DOXYGEN_SHOULD_SKIP_THIS
7684 
7685 private:
7686 
7687  TypeIdentifier m_type_identifier;
7688  TypeObject m_type_object;
7689 };
7690 typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
7691 
7692 /*struct TypeIdentifierPair final {
7693  TypeIdentifier type_identifier1;
7694  TypeIdentifier type_identifier2;
7695  };*/
7697 {
7698 public:
7699 
7700  RTPS_DllAPI TypeIdentifierPair();
7701  RTPS_DllAPI ~TypeIdentifierPair();
7702  RTPS_DllAPI TypeIdentifierPair(
7703  const TypeIdentifierPair& x);
7704  RTPS_DllAPI TypeIdentifierPair(
7705  TypeIdentifierPair&& x);
7707  const TypeIdentifierPair& x);
7709  TypeIdentifierPair&& x);
7710 
7711  RTPS_DllAPI inline void type_identifier1(
7712  const TypeIdentifier& _type_identifier1)
7713  {
7714  m_type_identifier1 = _type_identifier1;
7715  }
7716 
7717  RTPS_DllAPI inline void type_identifier1(
7718  TypeIdentifier&& _type_identifier1)
7719  {
7720  m_type_identifier1 = std::move(_type_identifier1);
7721  }
7722 
7723  RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const
7724  {
7725  return m_type_identifier1;
7726  }
7727 
7728  RTPS_DllAPI inline TypeIdentifier& type_identifier1()
7729  {
7730  return m_type_identifier1;
7731  }
7732 
7733  RTPS_DllAPI inline void type_identifier2(
7734  const TypeIdentifier& _type_identifier2)
7735  {
7736  m_type_identifier2 = _type_identifier2;
7737  }
7738 
7739  RTPS_DllAPI inline void type_identifier2(
7740  TypeIdentifier&& _type_identifier2)
7741  {
7742  m_type_identifier2 = std::move(_type_identifier2);
7743  }
7744 
7745  RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const
7746  {
7747  return m_type_identifier2;
7748  }
7749 
7750  RTPS_DllAPI inline TypeIdentifier& type_identifier2()
7751  {
7752  return m_type_identifier2;
7753  }
7754 
7755 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7756  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::getCdrSerializedSize()",
7757  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7758  RTPS_DllAPI static size_t getCdrSerializedSize(
7759  const TypeIdentifierPair& data,
7760  size_t current_alignment = 0);
7761  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::serialize()",
7762  "In favor of version using eprosima::fastcdr::serialize.")
7763  RTPS_DllAPI void serialize(
7764  eprosima::fastcdr::Cdr& cdr) const;
7765  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::deserialize()",
7766  "In favor of version using eprosima::fastcdr::deserialize.")
7767  RTPS_DllAPI void deserialize(
7768  eprosima::fastcdr::Cdr& cdr);
7769 #endif // DOXYGEN_SHOULD_SKIP_THIS
7770 
7771 private:
7772 
7773  TypeIdentifier m_type_identifier1;
7774  TypeIdentifier m_type_identifier2;
7775 };
7776 
7777 typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
7778 /*struct TypeIdentifierWithSize {
7779  TypeIdentifier type_id;
7780  uint32_t typeobject_serialized_size;
7781  };*/
7783 {
7784 public:
7785 
7786  RTPS_DllAPI TypeIdentifierWithSize();
7789  const TypeIdentifierWithSize& x);
7793  const TypeIdentifierWithSize& x);
7796 
7797  RTPS_DllAPI inline void type_id(
7798  const TypeIdentifier& _type_id)
7799  {
7800  m_type_id = _type_id;
7801  }
7802 
7803  RTPS_DllAPI inline void type_id(
7804  TypeIdentifier&& _type_id)
7805  {
7806  m_type_id = std::move(_type_id);
7807  }
7808 
7809  RTPS_DllAPI inline const TypeIdentifier& type_id() const
7810  {
7811  return m_type_id;
7812  }
7813 
7814  RTPS_DllAPI inline TypeIdentifier& type_id()
7815  {
7816  return m_type_id;
7817  }
7818 
7819  RTPS_DllAPI inline void typeobject_serialized_size(
7820  const uint32_t& _typeobject_serialized_size)
7821  {
7822  m_typeobject_serialized_size = _typeobject_serialized_size;
7823  }
7824 
7825  RTPS_DllAPI inline void typeobject_serialized_size(
7826  uint32_t&& _typeobject_serialized_size)
7827  {
7828  m_typeobject_serialized_size = std::move(_typeobject_serialized_size);
7829  }
7830 
7831  RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const
7832  {
7833  return m_typeobject_serialized_size;
7834  }
7835 
7836  RTPS_DllAPI inline uint32_t& typeobject_serialized_size()
7837  {
7838  return m_typeobject_serialized_size;
7839  }
7840 
7841 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7842  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::getCdrSerializedSize()",
7843  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7844  RTPS_DllAPI static size_t getCdrSerializedSize(
7845  const TypeIdentifierWithSize& data,
7846  size_t current_alignment = 0);
7847  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::serialize()",
7848  "In favor of version using eprosima::fastcdr::serialize.")
7849  RTPS_DllAPI void serialize(
7850  eprosima::fastcdr::Cdr& cdr) const;
7851  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::deserialize()",
7852  "In favor of version using eprosima::fastcdr::deserialize.")
7853  RTPS_DllAPI void deserialize(
7854  eprosima::fastcdr::Cdr& cdr);
7855 #endif // DOXYGEN_SHOULD_SKIP_THIS
7856 
7857 private:
7858 
7859  TypeIdentifier m_type_id;
7860  uint32_t m_typeobject_serialized_size;
7861 };
7862 
7863 typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;
7864 
7865 /*struct TypeIdentifierWithDependencies {
7866  TypeIdentifierWithSize typeid_with_size;
7867  // The total additional types related to minimal_type
7868  int32_t dependent_typeid_count;
7869  TypeIdentifierWithSizeSeq dependent_typeids;
7870  };*/
7872 {
7873 public:
7874 
7885 
7886  RTPS_DllAPI inline void typeid_with_size(
7887  const TypeIdentifierWithSize& _typeid_with_size)
7888  {
7889  m_typeid_with_size = _typeid_with_size;
7890  }
7891 
7892  RTPS_DllAPI inline void typeid_with_size(
7893  TypeIdentifierWithSize&& _typeid_with_size)
7894  {
7895  m_typeid_with_size = std::move(_typeid_with_size);
7896  }
7897 
7898  RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const
7899  {
7900  return m_typeid_with_size;
7901  }
7902 
7904  {
7905  return m_typeid_with_size;
7906  }
7907 
7908  RTPS_DllAPI inline void dependent_typeid_count(
7909  const int32_t& _dependent_typeid_count)
7910  {
7911  m_dependent_typeid_count = _dependent_typeid_count;
7912  }
7913 
7914  RTPS_DllAPI inline void dependent_typeid_count(
7915  int32_t&& _dependent_typeid_count)
7916  {
7917  m_dependent_typeid_count = std::move(_dependent_typeid_count);
7918  }
7919 
7920  RTPS_DllAPI inline const int32_t& dependent_typeid_count() const
7921  {
7922  return m_dependent_typeid_count;
7923  }
7924 
7925  RTPS_DllAPI inline int32_t& dependent_typeid_count()
7926  {
7927  return m_dependent_typeid_count;
7928  }
7929 
7930  RTPS_DllAPI inline void dependent_typeids(
7931  const TypeIdentifierWithSizeSeq& _dependent_typeids)
7932  {
7933  m_dependent_typeids = _dependent_typeids;
7934  }
7935 
7936  RTPS_DllAPI inline void dependent_typeids(
7937  TypeIdentifierWithSizeSeq&& _dependent_typeids)
7938  {
7939  m_dependent_typeids = std::move(_dependent_typeids);
7940  }
7941 
7942  RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const
7943  {
7944  return m_dependent_typeids;
7945  }
7946 
7948  {
7949  return m_dependent_typeids;
7950  }
7951 
7952 #ifndef DOXYGEN_SHOULD_SKIP_THIS
7953  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::getCdrSerializedSize()",
7954  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7955  RTPS_DllAPI static size_t getCdrSerializedSize(
7956  const TypeIdentifierWithDependencies& data,
7957  size_t current_alignment = 0);
7958  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::serialize()",
7959  "In favor of version using eprosima::fastcdr::serialize.")
7960  RTPS_DllAPI void serialize(
7961  eprosima::fastcdr::Cdr& cdr) const;
7962  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::deserialize()",
7963  "In favor of version using eprosima::fastcdr::deserialize.")
7964  RTPS_DllAPI void deserialize(
7965  eprosima::fastcdr::Cdr& cdr);
7966 #endif // DOXYGEN_SHOULD_SKIP_THIS
7967 
7968 private:
7969 
7970  TypeIdentifierWithSize m_typeid_with_size;
7971  int32_t m_dependent_typeid_count;
7972  TypeIdentifierWithSizeSeq m_dependent_typeids;
7973 };
7974 
7975 typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
7977 
7978 // This appears in the builtin DDS topics PublicationBuiltinTopicData
7979 // and SubscriptionBuiltinTopicData
7980 
7981 /*struct TypeInformation {
7982  TypeIdentifierWithDependencies minimal; // @id{0x1001}
7983  TypeIdentifierWithDependencies complete; // @id{0x1002}
7984  };*/
7986 {
7987 public:
7988 
7989  RTPS_DllAPI TypeInformation();
7990  RTPS_DllAPI ~TypeInformation();
7991  RTPS_DllAPI TypeInformation(
7992  const TypeInformation& x);
7993  RTPS_DllAPI TypeInformation(
7994  TypeInformation&& x);
7996  const TypeInformation& x);
7998  TypeInformation&& x);
7999 
8000  RTPS_DllAPI inline void minimal(
8001  const TypeIdentifierWithDependencies& _minimal)
8002  {
8003  m_minimal = _minimal;
8004  }
8005 
8006  RTPS_DllAPI inline void minimal(
8007  TypeIdentifierWithDependencies&& _minimal)
8008  {
8009  m_minimal = std::move(_minimal);
8010  }
8011 
8012  RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const
8013  {
8014  return m_minimal;
8015  }
8016 
8018  {
8019  return m_minimal;
8020  }
8021 
8022  RTPS_DllAPI inline void complete(
8023  const TypeIdentifierWithDependencies& _complete)
8024  {
8025  m_complete = _complete;
8026  }
8027 
8028  RTPS_DllAPI inline void complete(
8029  TypeIdentifierWithDependencies&& _complete)
8030  {
8031  m_complete = std::move(_complete);
8032  }
8033 
8034  RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const
8035  {
8036  return m_complete;
8037  }
8038 
8040  {
8041  return m_complete;
8042  }
8043 
8044 #ifndef DOXYGEN_SHOULD_SKIP_THIS
8045  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::getCdrSerializedSize()",
8046  "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
8047  RTPS_DllAPI static size_t getCdrSerializedSize(
8048  const TypeInformation& data,
8049  size_t current_alignment = 0);
8050 
8051  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::serialize()",
8052  "In favor of version using eprosima::fastcdr::serialize.")
8053  RTPS_DllAPI void serialize(
8054  eprosima::fastcdr::Cdr& cdr) const;
8055 
8056  FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::deserialize()",
8057  "In favor of version using eprosima::fastcdr::deserialize.")
8058  RTPS_DllAPI void deserialize(
8059  eprosima::fastcdr::Cdr& cdr);
8060 #endif // DOXYGEN_SHOULD_SKIP_THIS
8061 
8062 private:
8063 
8065  TypeIdentifierWithDependencies m_complete;
8066 };
8067 
8068 typedef std::vector<TypeInformation> TypeInformationSeq;
8070 
8071 } // namespace types
8072 } // namespace fastrtps
8073 } // namespace eprosima
8074 
8075 #endif // TYPES_TYPE_OBJECT_H
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:173
Definition: AnnotationParameterValue.h:1289
RTPS_DllAPI AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI const AppliedVerbatimAnnotation & verbatim() const
Definition: TypeObject.h:563
RTPS_DllAPI bool consistent(const AppliedBuiltinTypeAnnotations &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x)
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI void verbatim(AppliedVerbatimAnnotation &&_verbatim)
Definition: TypeObject.h:557
RTPS_DllAPI AppliedVerbatimAnnotation & verbatim()
Definition: TypeObject.h:568
RTPS_DllAPI bool operator==(const AppliedBuiltinTypeAnnotations &other) const
RTPS_DllAPI void verbatim(const AppliedVerbatimAnnotation &_verbatim)
Definition: TypeObject.h:551
Definition: AnnotationParameterValue.h:1159
Definition: TypeObject.h:2894
RTPS_DllAPI AliasMemberFlag & related_flags()
Definition: TypeObject.h:2925
RTPS_DllAPI TypeIdentifier & related_type()
Definition: TypeObject.h:2947
RTPS_DllAPI CommonAliasBody(const CommonAliasBody &x)
RTPS_DllAPI CommonAliasBody(CommonAliasBody &&x)
RTPS_DllAPI const AliasMemberFlag & related_flags() const
Definition: TypeObject.h:2920
RTPS_DllAPI const TypeIdentifier & related_type() const
Definition: TypeObject.h:2942
RTPS_DllAPI void related_flags(AliasMemberFlag &&_related_flags)
Definition: TypeObject.h:2914
RTPS_DllAPI void related_flags(const AliasMemberFlag &_related_flags)
Definition: TypeObject.h:2908
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:2936
RTPS_DllAPI void related_type(const TypeIdentifier &_related_type)
Definition: TypeObject.h:2930
RTPS_DllAPI const AnnotationParameterFlag & member_flags() const
Definition: TypeObject.h:2243
RTPS_DllAPI AnnotationParameterFlag & member_flags()
Definition: TypeObject.h:2248
RTPS_DllAPI CommonAnnotationParameter(CommonAnnotationParameter &&x)
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:2259
RTPS_DllAPI void member_flags(const AnnotationParameterFlag &_member_flags)
Definition: TypeObject.h:2231
RTPS_DllAPI CommonAnnotationParameter(const CommonAnnotationParameter &x)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:2253
RTPS_DllAPI void member_flags(AnnotationParameterFlag &&_member_flags)
Definition: TypeObject.h:2237
RTPS_DllAPI CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:2270
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:2265
RTPS_DllAPI bool consistent(const CommonArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI LBoundSeq & bound_seq()
Definition: TypeObject.h:4346
RTPS_DllAPI void bound_seq(const LBoundSeq &_bound_seq)
Definition: TypeObject.h:4329
RTPS_DllAPI CommonArrayHeader(const CommonArrayHeader &x)
RTPS_DllAPI const LBoundSeq & bound_seq() const
Definition: TypeObject.h:4341
RTPS_DllAPI CommonArrayHeader(CommonArrayHeader &&x)
RTPS_DllAPI void bound_seq(LBoundSeq &&_bound_seq)
Definition: TypeObject.h:4335
RTPS_DllAPI CommonArrayHeader & operator=(const CommonArrayHeader &x)
RTPS_DllAPI bool operator==(const CommonArrayHeader &other) const
Definition: TypeObject.h:6394
RTPS_DllAPI const BitsetMemberFlag & flags() const
Definition: TypeObject.h:6442
RTPS_DllAPI void bitcount(octet &&_bitcount)
Definition: TypeObject.h:6458
RTPS_DllAPI CommonBitfield(const CommonBitfield &x)
RTPS_DllAPI void holder_type(TypeKind &&_holder_type)
Definition: TypeObject.h:6480
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:6425
RTPS_DllAPI CommonBitfield & operator=(const CommonBitfield &x)
RTPS_DllAPI CommonBitfield(CommonBitfield &&x)
RTPS_DllAPI const octet & bitcount() const
Definition: TypeObject.h:6464
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:6474
RTPS_DllAPI BitsetMemberFlag & flags()
Definition: TypeObject.h:6447
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:6420
RTPS_DllAPI TypeKind & holder_type()
Definition: TypeObject.h:6491
RTPS_DllAPI void bitcount(const octet &_bitcount)
Definition: TypeObject.h:6452
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:6414
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:6408
RTPS_DllAPI const TypeKind & holder_type() const
Definition: TypeObject.h:6486
RTPS_DllAPI octet & bitcount()
Definition: TypeObject.h:6469
RTPS_DllAPI void flags(BitsetMemberFlag &&_flags)
Definition: TypeObject.h:6436
RTPS_DllAPI void flags(const BitsetMemberFlag &_flags)
Definition: TypeObject.h:6430
Definition: TypeObject.h:5809
RTPS_DllAPI CommonBitflag(const CommonBitflag &x)
RTPS_DllAPI CommonBitflag & operator=(const CommonBitflag &x)
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:5840
RTPS_DllAPI CommonBitflag(CommonBitflag &&x)
RTPS_DllAPI const BitflagFlag & flags() const
Definition: TypeObject.h:5857
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:5835
RTPS_DllAPI void flags(BitflagFlag &&_flags)
Definition: TypeObject.h:5851
RTPS_DllAPI bool consistent(const CommonBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void flags(const BitflagFlag &_flags)
Definition: TypeObject.h:5845
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:5829
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:5823
RTPS_DllAPI bool operator==(const CommonBitflag &other) const
RTPS_DllAPI BitflagFlag & flags()
Definition: TypeObject.h:5862
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:6102
RTPS_DllAPI CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
RTPS_DllAPI bool consistent(const CommonBitmaskHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:6119
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:6108
RTPS_DllAPI CommonBitmaskHeader(const CommonBitmaskHeader &x)
RTPS_DllAPI CommonBitmaskHeader(CommonBitmaskHeader &&x)
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:6114
RTPS_DllAPI bool operator==(const CommonBitmaskHeader &other) const
RTPS_DllAPI void element_flags(const CollectionElementFlag &_element_flags)
Definition: TypeObject.h:3616
RTPS_DllAPI CommonCollectionElement(CommonCollectionElement &&x)
RTPS_DllAPI bool operator==(const CommonCollectionElement &other) const
RTPS_DllAPI const TypeIdentifier & type() const
Definition: TypeObject.h:3650
RTPS_DllAPI void type(TypeIdentifier &&_type)
Definition: TypeObject.h:3644
RTPS_DllAPI void element_flags(CollectionElementFlag &&_element_flags)
Definition: TypeObject.h:3622
RTPS_DllAPI CollectionElementFlag & element_flags()
Definition: TypeObject.h:3633
RTPS_DllAPI TypeIdentifier & type()
Definition: TypeObject.h:3655
RTPS_DllAPI const CollectionElementFlag & element_flags() const
Definition: TypeObject.h:3628
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:3638
RTPS_DllAPI bool consistent(const CommonCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bound(const LBound &_bound)
Definition: TypeObject.h:3867
RTPS_DllAPI void bound(LBound &&_bound)
Definition: TypeObject.h:3873
RTPS_DllAPI CommonCollectionHeader(const CommonCollectionHeader &x)
RTPS_DllAPI CommonCollectionHeader(CommonCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CommonCollectionHeader &other) const
RTPS_DllAPI const LBound & bound() const
Definition: TypeObject.h:3879
RTPS_DllAPI CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
RTPS_DllAPI LBound & bound()
Definition: TypeObject.h:3884
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:1564
RTPS_DllAPI const UnionDiscriminatorFlag & member_flags() const
Definition: TypeObject.h:1548
RTPS_DllAPI bool consistent(const CommonDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI UnionDiscriminatorFlag & member_flags()
Definition: TypeObject.h:1553
RTPS_DllAPI bool operator==(const CommonDiscriminatorMember &other) const
RTPS_DllAPI void member_flags(const UnionDiscriminatorFlag &_member_flags)
Definition: TypeObject.h:1536
RTPS_DllAPI CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:1575
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:1558
RTPS_DllAPI CommonDiscriminatorMember(CommonDiscriminatorMember &&x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:1570
RTPS_DllAPI CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
RTPS_DllAPI void member_flags(UnionDiscriminatorFlag &&_member_flags)
Definition: TypeObject.h:1542
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:5359
RTPS_DllAPI bool consistent(const CommonEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:5376
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:5365
RTPS_DllAPI CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:5371
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:5087
RTPS_DllAPI void flags(const EnumeratedLiteralFlag &_flags)
Definition: TypeObject.h:5097
RTPS_DllAPI const EnumeratedLiteralFlag & flags() const
Definition: TypeObject.h:5109
RTPS_DllAPI void flags(EnumeratedLiteralFlag &&_flags)
Definition: TypeObject.h:5103
RTPS_DllAPI CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
RTPS_DllAPI EnumeratedLiteralFlag & flags()
Definition: TypeObject.h:5114
RTPS_DllAPI bool operator==(const CommonEnumeratedLiteral &other) const
RTPS_DllAPI void value(const int32_t &_value)
Definition: TypeObject.h:5075
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:5092
RTPS_DllAPI void value(int32_t &&_value)
Definition: TypeObject.h:5081
RTPS_DllAPI void member_flags(const StructMemberFlag &_member_flags)
Definition: TypeObject.h:80
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:70
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:75
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:108
RTPS_DllAPI CommonStructMember & operator=(const CommonStructMember &x)
RTPS_DllAPI bool operator==(const CommonStructMember &other) const
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:102
RTPS_DllAPI bool consistent(const CommonStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:64
RTPS_DllAPI StructMemberFlag & member_flags()
Definition: TypeObject.h:97
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:119
RTPS_DllAPI const StructMemberFlag & member_flags() const
Definition: TypeObject.h:92
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:58
RTPS_DllAPI CommonStructMember(const CommonStructMember &x)
RTPS_DllAPI CommonStructMember(CommonStructMember &&x)
RTPS_DllAPI void member_flags(StructMemberFlag &&_member_flags)
Definition: TypeObject.h:86
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:114
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:1218
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:1256
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:1223
RTPS_DllAPI UnionCaseLabelSeq & label_seq()
Definition: TypeObject.h:1289
RTPS_DllAPI void member_flags(UnionMemberFlag &&_member_flags)
Definition: TypeObject.h:1234
RTPS_DllAPI void member_flags(const UnionMemberFlag &_member_flags)
Definition: TypeObject.h:1228
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:1212
RTPS_DllAPI void label_seq(const UnionCaseLabelSeq &_label_seq)
Definition: TypeObject.h:1272
RTPS_DllAPI const UnionCaseLabelSeq & label_seq() const
Definition: TypeObject.h:1284
RTPS_DllAPI bool consistent(const CommonUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonUnionMember(const CommonUnionMember &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:1267
RTPS_DllAPI CommonUnionMember(CommonUnionMember &&x)
RTPS_DllAPI const UnionMemberFlag & member_flags() const
Definition: TypeObject.h:1240
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:1206
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:1250
RTPS_DllAPI void label_seq(UnionCaseLabelSeq &&_label_seq)
Definition: TypeObject.h:1278
RTPS_DllAPI UnionMemberFlag & member_flags()
Definition: TypeObject.h:1245
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:1262
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:3017
RTPS_DllAPI bool operator==(const CompleteAliasBody &other) const
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:3061
RTPS_DllAPI CompleteAliasBody(const CompleteAliasBody &x)
RTPS_DllAPI CompleteAliasBody(CompleteAliasBody &&x)
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:3000
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:3056
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:3034
RTPS_DllAPI CompleteAliasBody & operator=(const CompleteAliasBody &x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:3006
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:3039
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:3012
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:3050
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:3044
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:3022
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:3028
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3197
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3186
RTPS_DllAPI CompleteAliasHeader(CompleteAliasHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3180
RTPS_DllAPI bool operator==(const CompleteAliasHeader &other) const
RTPS_DllAPI CompleteAliasHeader(const CompleteAliasHeader &x)
RTPS_DllAPI CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3192
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:3296
RTPS_DllAPI void header(CompleteAliasHeader &&_header)
Definition: TypeObject.h:3324
RTPS_DllAPI void body(CompleteAliasBody &&_body)
Definition: TypeObject.h:3346
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:3302
RTPS_DllAPI CompleteAliasType & operator=(const CompleteAliasType &x)
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:3308
RTPS_DllAPI void body(const CompleteAliasBody &_body)
Definition: TypeObject.h:3340
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:3313
RTPS_DllAPI const CompleteAliasHeader & header() const
Definition: TypeObject.h:3330
RTPS_DllAPI const CompleteAliasBody & body() const
Definition: TypeObject.h:3352
RTPS_DllAPI bool operator==(const CompleteAliasType &other) const
RTPS_DllAPI void header(const CompleteAliasHeader &_header)
Definition: TypeObject.h:3318
RTPS_DllAPI CompleteAliasHeader & header()
Definition: TypeObject.h:3335
RTPS_DllAPI CompleteAliasType(CompleteAliasType &&x)
RTPS_DllAPI CompleteAliasBody & body()
Definition: TypeObject.h:3357
RTPS_DllAPI CompleteAliasType(const CompleteAliasType &x)
RTPS_DllAPI void annotation_name(const QualifiedTypeName &_annotation_name)
Definition: TypeObject.h:2559
RTPS_DllAPI void annotation_name(QualifiedTypeName &&_annotation_name)
Definition: TypeObject.h:2565
RTPS_DllAPI bool consistent(const CompleteAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationHeader(CompleteAnnotationHeader &&x)
RTPS_DllAPI bool operator==(const CompleteAnnotationHeader &other) const
RTPS_DllAPI QualifiedTypeName & annotation_name()
Definition: TypeObject.h:2576
RTPS_DllAPI const QualifiedTypeName & annotation_name() const
Definition: TypeObject.h:2571
RTPS_DllAPI CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
RTPS_DllAPI CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:2360
RTPS_DllAPI CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:2387
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:2338
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:2382
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:2326
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:2370
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:2348
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:2332
RTPS_DllAPI CompleteAnnotationParameter(CompleteAnnotationParameter &&x)
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:2365
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:2354
RTPS_DllAPI bool consistent(const CompleteAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:2343
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:2376
RTPS_DllAPI bool operator==(const CompleteAnnotationParameter &other) const
RTPS_DllAPI void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:2727
RTPS_DllAPI const CompleteAnnotationHeader & header() const
Definition: TypeObject.h:2711
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:2677
RTPS_DllAPI void header(CompleteAnnotationHeader &&_header)
Definition: TypeObject.h:2705
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:2683
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 CompleteAnnotationType(const CompleteAnnotationType &x)
RTPS_DllAPI CompleteAnnotationType(CompleteAnnotationType &&x)
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:2689
RTPS_DllAPI void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:2721
RTPS_DllAPI CompleteAnnotationHeader & header()
Definition: TypeObject.h:2716
RTPS_DllAPI CompleteAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:2738
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:2694
RTPS_DllAPI const CompleteAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:2733
RTPS_DllAPI void header(const CompleteAnnotationHeader &_header)
Definition: TypeObject.h:2699
RTPS_DllAPI bool consistent(const CompleteArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:4437
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:4404
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:4426
RTPS_DllAPI CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:4410
RTPS_DllAPI CompleteArrayHeader(CompleteArrayHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:4420
RTPS_DllAPI bool operator==(const CompleteArrayHeader &other) const
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition: TypeObject.h:4398
RTPS_DllAPI CompleteArrayHeader(const CompleteArrayHeader &x)
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:4415
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:4432
RTPS_DllAPI void header(const CompleteArrayHeader &_header)
Definition: TypeObject.h:4581
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:4615
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:4603
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:4609
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:4620
RTPS_DllAPI CompleteArrayHeader & header()
Definition: TypeObject.h:4598
RTPS_DllAPI void header(CompleteArrayHeader &&_header)
Definition: TypeObject.h:4587
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:4559
RTPS_DllAPI CompleteArrayType(CompleteArrayType &&x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4571
RTPS_DllAPI bool operator==(const CompleteArrayType &other) const
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4576
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4565
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:4593
RTPS_DllAPI CompleteArrayType & operator=(const CompleteArrayType &x)
Definition: TypeObject.h:6532
RTPS_DllAPI CompleteBitfield & operator=(const CompleteBitfield &x)
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:6563
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:6546
RTPS_DllAPI CompleteBitfield(CompleteBitfield &&x)
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:6558
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:6585
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:6552
RTPS_DllAPI bool consistent(const CompleteBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:6580
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:6568
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:6574
RTPS_DllAPI bool operator==(const CompleteBitfield &other) const
RTPS_DllAPI CompleteBitfield(const CompleteBitfield &x)
Definition: TypeObject.h:5901
RTPS_DllAPI CompleteBitflag(CompleteBitflag &&x)
RTPS_DllAPI CompleteBitflag & operator=(const CompleteBitflag &x)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:5921
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:5954
RTPS_DllAPI bool consistent(const CompleteBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:5927
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:5949
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:5937
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:5943
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:5915
RTPS_DllAPI bool operator==(const CompleteBitflag &other) const
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:5932
RTPS_DllAPI CompleteBitflag(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitmaskType(const CompleteBitmaskType &x)
RTPS_DllAPI void header(const CompleteBitmaskHeader &_header)
Definition: TypeObject.h:6196
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:6180
RTPS_DllAPI const CompleteBitmaskHeader & header() const
Definition: TypeObject.h:6208
RTPS_DllAPI void flag_seq(const CompleteBitflagSeq &_flag_seq)
Definition: TypeObject.h:6218
RTPS_DllAPI bool operator==(const CompleteBitmaskType &other) const
RTPS_DllAPI CompleteBitmaskHeader & header()
Definition: TypeObject.h:6213
RTPS_DllAPI void flag_seq(CompleteBitflagSeq &&_flag_seq)
Definition: TypeObject.h:6224
RTPS_DllAPI CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
RTPS_DllAPI void header(CompleteBitmaskHeader &&_header)
Definition: TypeObject.h:6202
RTPS_DllAPI CompleteBitmaskType(CompleteBitmaskType &&x)
RTPS_DllAPI const CompleteBitflagSeq & flag_seq() const
Definition: TypeObject.h:6230
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:6174
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:6191
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:6186
RTPS_DllAPI CompleteBitflagSeq & flag_seq()
Definition: TypeObject.h:6235
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:6770
RTPS_DllAPI bool operator==(const CompleteBitsetHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:6759
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:6748
RTPS_DllAPI bool consistent(const CompleteBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:6753
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:6743
RTPS_DllAPI CompleteBitsetHeader(const CompleteBitsetHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:6731
RTPS_DllAPI CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:6765
RTPS_DllAPI CompleteBitsetHeader(CompleteBitsetHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:6737
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:6897
RTPS_DllAPI void header(const CompleteBitsetHeader &_header)
Definition: TypeObject.h:6913
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:6908
RTPS_DllAPI const CompleteBitfieldSeq & field_seq() const
Definition: TypeObject.h:6947
RTPS_DllAPI bool consistent(const CompleteBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(CompleteBitsetHeader &&_header)
Definition: TypeObject.h:6919
RTPS_DllAPI CompleteBitsetType(const CompleteBitsetType &x)
RTPS_DllAPI CompleteBitsetHeader & header()
Definition: TypeObject.h:6930
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:6891
RTPS_DllAPI void field_seq(CompleteBitfieldSeq &&_field_seq)
Definition: TypeObject.h:6941
RTPS_DllAPI const CompleteBitsetHeader & header() const
Definition: TypeObject.h:6925
RTPS_DllAPI CompleteBitfieldSeq & field_seq()
Definition: TypeObject.h:6952
RTPS_DllAPI CompleteBitsetType(CompleteBitsetType &&x)
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:6903
RTPS_DllAPI void field_seq(const CompleteBitfieldSeq &_field_seq)
Definition: TypeObject.h:6935
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:3725
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:3720
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:3708
RTPS_DllAPI void detail(CompleteElementDetail &&_detail)
Definition: TypeObject.h:3736
RTPS_DllAPI CompleteCollectionElement(const CompleteCollectionElement &x)
RTPS_DllAPI CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
RTPS_DllAPI const CompleteElementDetail & detail() const
Definition: TypeObject.h:3742
RTPS_DllAPI CompleteCollectionElement(CompleteCollectionElement &&x)
RTPS_DllAPI void detail(const CompleteElementDetail &_detail)
Definition: TypeObject.h:3730
RTPS_DllAPI bool consistent(const CompleteCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:3714
RTPS_DllAPI CompleteElementDetail & detail()
Definition: TypeObject.h:3747
RTPS_DllAPI bool operator==(const CompleteCollectionElement &other) const
RTPS_DllAPI CompleteCollectionHeader(const CompleteCollectionHeader &x)
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition: TypeObject.h:3948
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3975
RTPS_DllAPI bool consistent(const CompleteCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3964
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:3936
RTPS_DllAPI CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3958
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:3953
RTPS_DllAPI CompleteCollectionHeader(CompleteCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CompleteCollectionHeader &other) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3970
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:3942
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:1636
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:1691
RTPS_DllAPI CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:1647
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:1664
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:1652
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:1669
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:1686
RTPS_DllAPI bool consistent(const CompleteDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:1658
RTPS_DllAPI CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x)
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:1630
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:1680
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:1642
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:1674
RTPS_DllAPI CompleteElementDetail(const CompleteElementDetail &x)
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:3564
RTPS_DllAPI bool operator==(const CompleteElementDetail &other) const
RTPS_DllAPI CompleteElementDetail(CompleteElementDetail &&x)
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:3559
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:3537
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:3542
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:3553
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:3547
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:3525
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:3531
RTPS_DllAPI CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x)
RTPS_DllAPI bool consistent(const CompleteEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:5467
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:5456
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:5450
RTPS_DllAPI bool operator==(const CompleteEnumeratedHeader &other) const
RTPS_DllAPI CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:5445
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:5462
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:5428
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:5434
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:5440
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:5175
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI bool consistent(const CompleteEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:5208
RTPS_DllAPI CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:5181
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:5203
RTPS_DllAPI CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:5191
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:5197
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:5169
RTPS_DllAPI bool operator==(const CompleteEnumeratedLiteral &other) const
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:5186
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:5607
RTPS_DllAPI bool consistent(const CompleteEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:5602
RTPS_DllAPI CompleteEnumeratedType(const CompleteEnumeratedType &x)
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:5590
RTPS_DllAPI CompleteEnumeratedHeader & header()
Definition: TypeObject.h:5629
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:5596
RTPS_DllAPI CompleteEnumeratedType(CompleteEnumeratedType &&x)
RTPS_DllAPI CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
RTPS_DllAPI CompleteEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:5651
RTPS_DllAPI const CompleteEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:5646
RTPS_DllAPI void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:5640
RTPS_DllAPI void header(CompleteEnumeratedHeader &&_header)
Definition: TypeObject.h:5618
RTPS_DllAPI bool operator==(const CompleteEnumeratedType &other) const
RTPS_DllAPI void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
Definition: TypeObject.h:5634
RTPS_DllAPI void header(const CompleteEnumeratedHeader &_header)
Definition: TypeObject.h:5612
RTPS_DllAPI const CompleteEnumeratedHeader & header() const
Definition: TypeObject.h:5624
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 bool operator==(const CompleteExtendedType &) const
Definition: TypeObject.h:7141
Definition: TypeObject.h:4779
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:4827
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:4871
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:4859
RTPS_DllAPI void key(const CompleteCollectionElement &_key)
Definition: TypeObject.h:4837
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:4815
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:4865
RTPS_DllAPI CompleteCollectionElement & key()
Definition: TypeObject.h:4854
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:4876
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:4793
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:4821
RTPS_DllAPI void key(CompleteCollectionElement &&_key)
Definition: TypeObject.h:4843
RTPS_DllAPI CompleteMapType & operator=(const CompleteMapType &x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4805
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:4832
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4810
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4799
RTPS_DllAPI CompleteMapType(const CompleteMapType &x)
RTPS_DllAPI CompleteMapType(CompleteMapType &&x)
RTPS_DllAPI const CompleteCollectionElement & key() const
Definition: TypeObject.h:4849
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:187
RTPS_DllAPI bool consistent(const CompleteMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:236
RTPS_DllAPI bool operator==(const CompleteMemberDetail &other) const
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:175
RTPS_DllAPI CompleteMemberDetail(const CompleteMemberDetail &x)
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:192
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:181
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:231
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:209
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:214
RTPS_DllAPI CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:225
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:219
RTPS_DllAPI CompleteMemberDetail(CompleteMemberDetail &&x)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:197
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:203
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition: TypeObject.h:4132
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:4154
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:4142
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:4120
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:4148
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:4159
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:4098
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:4126
RTPS_DllAPI bool consistent(const CompleteSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4110
RTPS_DllAPI CompleteSequenceType(const CompleteSequenceType &x)
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:4137
RTPS_DllAPI CompleteSequenceType & operator=(const CompleteSequenceType &x)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4115
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4104
RTPS_DllAPI bool operator==(const CompleteSequenceType &other) const
RTPS_DllAPI CompleteSequenceType(CompleteSequenceType &&x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:822
RTPS_DllAPI bool operator==(const CompleteStructHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:811
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:800
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:805
RTPS_DllAPI CompleteStructHeader(const CompleteStructHeader &x)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:795
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:783
RTPS_DllAPI CompleteStructHeader(CompleteStructHeader &&x)
RTPS_DllAPI CompleteStructHeader & operator=(const CompleteStructHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:817
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:789
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:378
RTPS_DllAPI CompleteStructMember(CompleteStructMember &&x)
RTPS_DllAPI bool operator==(const CompleteStructMember &other) const
RTPS_DllAPI CompleteStructMember & operator=(const CompleteStructMember &x)
RTPS_DllAPI CompleteStructMember(const CompleteStructMember &x)
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:400
RTPS_DllAPI bool consistent(const CompleteStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:361
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:373
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:395
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:383
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:389
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:367
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:973
RTPS_DllAPI void header(const CompleteStructHeader &_header)
Definition: TypeObject.h:989
RTPS_DllAPI CompleteStructType(CompleteStructType &&x)
RTPS_DllAPI const CompleteStructHeader & header() const
Definition: TypeObject.h:1001
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:984
RTPS_DllAPI CompleteStructType(const CompleteStructType &x)
RTPS_DllAPI const CompleteStructMemberSeq & member_seq() const
Definition: TypeObject.h:1023
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:967
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:979
RTPS_DllAPI CompleteStructHeader & header()
Definition: TypeObject.h:1006
RTPS_DllAPI CompleteStructMemberSeq & member_seq()
Definition: TypeObject.h:1028
RTPS_DllAPI CompleteStructType & operator=(const CompleteStructType &x)
RTPS_DllAPI void member_seq(const CompleteStructMemberSeq &_member_seq)
Definition: TypeObject.h:1011
RTPS_DllAPI bool consistent(const CompleteStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(CompleteStructHeader &&_header)
Definition: TypeObject.h:995
RTPS_DllAPI void member_seq(CompleteStructMemberSeq &&_member_seq)
Definition: TypeObject.h:1017
RTPS_DllAPI bool operator==(const CompleteStructType &other) const
RTPS_DllAPI CompleteTypeDetail(const CompleteTypeDetail &x)
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:708
RTPS_DllAPI CompleteTypeDetail(CompleteTypeDetail &&x)
RTPS_DllAPI QualifiedTypeName & type_name()
Definition: TypeObject.h:730
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:681
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:669
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:686
RTPS_DllAPI bool consistent(const CompleteTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:703
RTPS_DllAPI const QualifiedTypeName & type_name() const
Definition: TypeObject.h:725
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:675
RTPS_DllAPI CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
RTPS_DllAPI void type_name(const QualifiedTypeName &_type_name)
Definition: TypeObject.h:713
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:697
RTPS_DllAPI bool operator==(const CompleteTypeDetail &other) const
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:691
RTPS_DllAPI void type_name(QualifiedTypeName &&_type_name)
Definition: TypeObject.h:719
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)
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 const CompleteEnumeratedType & enumerated_type() const
RTPS_DllAPI const CompleteSequenceType & sequence_type() 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 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:1830
RTPS_DllAPI CompleteUnionHeader(const CompleteUnionHeader &x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:1819
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:1813
RTPS_DllAPI bool consistent(const CompleteUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:1825
RTPS_DllAPI CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
RTPS_DllAPI CompleteUnionMember(const CompleteUnionMember &x)
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition: TypeObject.h:1345
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:1351
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:1362
RTPS_DllAPI bool consistent(const CompleteUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:1384
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:1379
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:1357
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:1367
RTPS_DllAPI CompleteUnionMember(CompleteUnionMember &&x)
RTPS_DllAPI CompleteUnionMember & operator=(const CompleteUnionMember &x)
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:1373
RTPS_DllAPI bool operator==(const CompleteUnionMember &other) const
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:1964
RTPS_DllAPI void discriminator(const CompleteDiscriminatorMember &_discriminator)
Definition: TypeObject.h:1996
RTPS_DllAPI const CompleteUnionMemberSeq & member_seq() const
Definition: TypeObject.h:2030
RTPS_DllAPI const CompleteUnionHeader & header() const
Definition: TypeObject.h:1986
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:1969
RTPS_DllAPI bool consistent(const CompleteUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteDiscriminatorMember & discriminator() const
Definition: TypeObject.h:2008
RTPS_DllAPI CompleteUnionMemberSeq & member_seq()
Definition: TypeObject.h:2035
RTPS_DllAPI CompleteUnionHeader & header()
Definition: TypeObject.h:1991
RTPS_DllAPI void member_seq(CompleteUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:2024
RTPS_DllAPI CompleteUnionType & operator=(const CompleteUnionType &x)
RTPS_DllAPI bool operator==(const CompleteUnionType &other) const
RTPS_DllAPI CompleteUnionType(const CompleteUnionType &x)
RTPS_DllAPI void header(const CompleteUnionHeader &_header)
Definition: TypeObject.h:1974
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:1952
RTPS_DllAPI void member_seq(const CompleteUnionMemberSeq &_member_seq)
Definition: TypeObject.h:2018
RTPS_DllAPI CompleteUnionType(CompleteUnionType &&x)
RTPS_DllAPI CompleteDiscriminatorMember & discriminator()
Definition: TypeObject.h:2013
RTPS_DllAPI void discriminator(CompleteDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:2002
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:1958
RTPS_DllAPI void header(CompleteUnionHeader &&_header)
Definition: TypeObject.h:1980
Definition: TypesBase.h:336
Definition: TypeObject.h:3099
RTPS_DllAPI bool operator==(const MinimalAliasBody &other) const
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:3130
RTPS_DllAPI MinimalAliasBody(const MinimalAliasBody &x)
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:3113
RTPS_DllAPI MinimalAliasBody(MinimalAliasBody &&x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:3119
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:3125
RTPS_DllAPI MinimalAliasBody & operator=(const MinimalAliasBody &x)
RTPS_DllAPI MinimalAliasHeader(MinimalAliasHeader &&x)
RTPS_DllAPI bool operator==(const MinimalAliasHeader &) const
Definition: TypeObject.h:3263
RTPS_DllAPI MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
RTPS_DllAPI MinimalAliasHeader(const MinimalAliasHeader &x)
Definition: TypeObject.h:3396
RTPS_DllAPI void header(const MinimalAliasHeader &_header)
Definition: TypeObject.h:3432
RTPS_DllAPI bool operator==(const MinimalAliasType &other) const
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:3410
RTPS_DllAPI const MinimalAliasBody & body() const
Definition: TypeObject.h:3466
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:3416
RTPS_DllAPI MinimalAliasType(const MinimalAliasType &x)
RTPS_DllAPI MinimalAliasHeader & header()
Definition: TypeObject.h:3449
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:3422
RTPS_DllAPI void body(const MinimalAliasBody &_body)
Definition: TypeObject.h:3454
RTPS_DllAPI MinimalAliasType & operator=(const MinimalAliasType &x)
RTPS_DllAPI void header(MinimalAliasHeader &&_header)
Definition: TypeObject.h:3438
RTPS_DllAPI const MinimalAliasHeader & header() const
Definition: TypeObject.h:3444
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:3427
RTPS_DllAPI MinimalAliasType(MinimalAliasType &&x)
RTPS_DllAPI MinimalAliasBody & body()
Definition: TypeObject.h:3471
RTPS_DllAPI void body(MinimalAliasBody &&_body)
Definition: TypeObject.h:3460
RTPS_DllAPI MinimalAnnotationHeader(MinimalAnnotationHeader &&x)
RTPS_DllAPI MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
RTPS_DllAPI MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
RTPS_DllAPI bool operator==(const MinimalAnnotationHeader &) const
Definition: TypeObject.h:2643
RTPS_DllAPI bool consistent(const MinimalAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:2477
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:2504
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:2455
RTPS_DllAPI bool consistent(const MinimalAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:2499
RTPS_DllAPI MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:2443
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:2487
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:2465
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:2449
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:2482
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:2471
RTPS_DllAPI MinimalAnnotationParameter(MinimalAnnotationParameter &&x)
RTPS_DllAPI bool operator==(const MinimalAnnotationParameter &other) const
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:2460
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:2493
RTPS_DllAPI MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
RTPS_DllAPI const MinimalAnnotationHeader & header() const
Definition: TypeObject.h:2826
RTPS_DllAPI MinimalAnnotationType(MinimalAnnotationType &&x)
RTPS_DllAPI MinimalAnnotationHeader & header()
Definition: TypeObject.h:2831
RTPS_DllAPI void header(const MinimalAnnotationHeader &_header)
Definition: TypeObject.h:2814
RTPS_DllAPI void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:2836
RTPS_DllAPI MinimalAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:2853
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:2792
RTPS_DllAPI void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:2842
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:2798
RTPS_DllAPI void header(MinimalAnnotationHeader &&_header)
Definition: TypeObject.h:2820
RTPS_DllAPI bool consistent(const MinimalAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:2848
RTPS_DllAPI MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:2804
RTPS_DllAPI MinimalAnnotationType(const MinimalAnnotationType &x)
RTPS_DllAPI bool operator==(const MinimalAnnotationType &other) const
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:2809
RTPS_DllAPI MinimalArrayHeader(MinimalArrayHeader &&x)
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:4495
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:4501
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:4489
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:4506
RTPS_DllAPI MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
RTPS_DllAPI MinimalArrayHeader(const MinimalArrayHeader &x)
Definition: TypeObject.h:4661
RTPS_DllAPI MinimalArrayType & operator=(const MinimalArrayType &x)
RTPS_DllAPI void header(const MinimalArrayHeader &_header)
Definition: TypeObject.h:4697
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:4675
RTPS_DllAPI MinimalArrayType(MinimalArrayType &&x)
RTPS_DllAPI void header(MinimalArrayHeader &&_header)
Definition: TypeObject.h:4703
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:4731
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:4736
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4687
RTPS_DllAPI MinimalArrayType(const MinimalArrayType &x)
RTPS_DllAPI bool operator==(const MinimalArrayType &other) const
RTPS_DllAPI const MinimalArrayHeader & header() const
Definition: TypeObject.h:4709
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:4719
RTPS_DllAPI MinimalArrayHeader & header()
Definition: TypeObject.h:4714
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4692
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4681
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:4725
Definition: TypeObject.h:6625
RTPS_DllAPI MinimalBitfield(MinimalBitfield &&x)
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:6656
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:6678
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:6661
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:6673
RTPS_DllAPI MinimalBitfield & operator=(const MinimalBitfield &x)
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:6651
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:6667
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:6639
RTPS_DllAPI bool consistent(const MinimalBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:6645
Definition: TypeObject.h:5994
RTPS_DllAPI MinimalBitflag(const MinimalBitflag &x)
RTPS_DllAPI MinimalBitflag & operator=(const MinimalBitflag &x)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:6014
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:6047
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:6020
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:6036
RTPS_DllAPI bool operator==(const MinimalBitflag &other) const
RTPS_DllAPI bool consistent(const MinimalBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:6042
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:6008
RTPS_DllAPI MinimalBitflag(MinimalBitflag &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:6030
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:6025
RTPS_DllAPI MinimalBitmaskHeader & header()
Definition: TypeObject.h:6329
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:6296
RTPS_DllAPI const MinimalBitmaskHeader & header() const
Definition: TypeObject.h:6324
RTPS_DllAPI void flag_seq(MinimalBitflagSeq &&_flag_seq)
Definition: TypeObject.h:6340
RTPS_DllAPI MinimalBitmaskType(MinimalBitmaskType &&x)
RTPS_DllAPI void header(const MinimalBitmaskHeader &_header)
Definition: TypeObject.h:6312
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:6351
RTPS_DllAPI MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
RTPS_DllAPI void flag_seq(const MinimalBitflagSeq &_flag_seq)
Definition: TypeObject.h:6334
RTPS_DllAPI MinimalBitmaskType(const MinimalBitmaskType &x)
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition: TypeObject.h:6290
RTPS_DllAPI void header(MinimalBitmaskHeader &&_header)
Definition: TypeObject.h:6318
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:6307
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:6302
RTPS_DllAPI const MinimalBitflagSeq & flag_seq() const
Definition: TypeObject.h:6346
RTPS_DllAPI MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
RTPS_DllAPI MinimalBitsetHeader(MinimalBitsetHeader &&x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:6839
RTPS_DllAPI bool operator==(const MinimalBitsetHeader &other) const
RTPS_DllAPI MinimalBitsetHeader(const MinimalBitsetHeader &x)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:6834
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:6822
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:6828
RTPS_DllAPI bool consistent(const MinimalBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:7013
RTPS_DllAPI MinimalBitsetType & operator=(const MinimalBitsetType &x)
RTPS_DllAPI bool operator==(const MinimalBitsetType &other) const
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:7024
RTPS_DllAPI void header(MinimalBitsetHeader &&_header)
Definition: TypeObject.h:7035
RTPS_DllAPI const MinimalBitfieldSeq & field_seq() const
Definition: TypeObject.h:7063
RTPS_DllAPI const MinimalBitsetHeader & header() const
Definition: TypeObject.h:7041
RTPS_DllAPI void field_seq(MinimalBitfieldSeq &&_field_seq)
Definition: TypeObject.h:7057
RTPS_DllAPI void header(const MinimalBitsetHeader &_header)
Definition: TypeObject.h:7029
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition: TypeObject.h:7007
RTPS_DllAPI void field_seq(const MinimalBitfieldSeq &_field_seq)
Definition: TypeObject.h:7051
RTPS_DllAPI MinimalBitsetType(const MinimalBitsetType &x)
RTPS_DllAPI MinimalBitsetHeader & header()
Definition: TypeObject.h:7046
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:7019
RTPS_DllAPI MinimalBitsetType(MinimalBitsetType &&x)
RTPS_DllAPI MinimalBitfieldSeq & field_seq()
Definition: TypeObject.h:7068
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:3816
RTPS_DllAPI MinimalCollectionElement(const MinimalCollectionElement &x)
RTPS_DllAPI MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:3811
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:3799
RTPS_DllAPI bool operator==(const MinimalCollectionElement &other) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:3805
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:4039
RTPS_DllAPI bool consistent(const MinimalCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:4027
RTPS_DllAPI MinimalCollectionHeader(MinimalCollectionHeader &&x)
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:4044
RTPS_DllAPI MinimalCollectionHeader(const MinimalCollectionHeader &x)
RTPS_DllAPI bool operator==(const MinimalCollectionHeader &other) const
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:4033
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:1751
RTPS_DllAPI MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x)
RTPS_DllAPI bool consistent(const MinimalDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
RTPS_DllAPI MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:1762
RTPS_DllAPI bool operator==(const MinimalDiscriminatorMember &other) const
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:1745
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:1757
RTPS_DllAPI bool consistent(const MinimalEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x)
RTPS_DllAPI MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
RTPS_DllAPI bool operator==(const MinimalEnumeratedHeader &other) const
RTPS_DllAPI MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:5536
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:5519
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:5525
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:5531
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:5271
RTPS_DllAPI MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:5304
RTPS_DllAPI bool consistent(const MinimalEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:5293
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:5277
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:5265
RTPS_DllAPI bool operator==(const MinimalEnumeratedLiteral &other) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:5299
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:5282
RTPS_DllAPI MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:5287
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:5723
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:5750
RTPS_DllAPI bool operator==(const MinimalEnumeratedType &other) const
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:5718
RTPS_DllAPI MinimalEnumeratedHeader & header()
Definition: TypeObject.h:5745
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:5706
RTPS_DllAPI MinimalEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:5767
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:5712
RTPS_DllAPI MinimalEnumeratedType(MinimalEnumeratedType &&x)
RTPS_DllAPI const MinimalEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:5762
RTPS_DllAPI MinimalEnumeratedType(const MinimalEnumeratedType &x)
RTPS_DllAPI const MinimalEnumeratedHeader & header() const
Definition: TypeObject.h:5740
RTPS_DllAPI void header(const MinimalEnumeratedHeader &_header)
Definition: TypeObject.h:5728
RTPS_DllAPI MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
RTPS_DllAPI void header(MinimalEnumeratedHeader &&_header)
Definition: TypeObject.h:5734
RTPS_DllAPI void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:5756
RTPS_DllAPI MinimalExtendedType(MinimalExtendedType &&x)
RTPS_DllAPI MinimalExtendedType(const MinimalExtendedType &x)
RTPS_DllAPI MinimalExtendedType & operator=(const MinimalExtendedType &x)
RTPS_DllAPI bool operator==(const MinimalExtendedType &) const
Definition: TypeObject.h:7189
RTPS_DllAPI bool consistent(const MinimalExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
Definition: TypeObject.h:4918
RTPS_DllAPI MinimalCollectionElement & key()
Definition: TypeObject.h:4993
RTPS_DllAPI void key(MinimalCollectionElement &&_key)
Definition: TypeObject.h:4982
RTPS_DllAPI void key(const MinimalCollectionElement &_key)
Definition: TypeObject.h:4976
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:4966
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:4932
RTPS_DllAPI MinimalMapType(MinimalMapType &&x)
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:5010
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:5015
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4944
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:4971
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:4998
RTPS_DllAPI MinimalMapType & operator=(const MinimalMapType &x)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4949
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4938
RTPS_DllAPI bool operator==(const MinimalMapType &other) const
RTPS_DllAPI const MinimalCollectionElement & key() const
Definition: TypeObject.h:4988
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:4960
RTPS_DllAPI MinimalMapType(const MinimalMapType &x)
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:5004
RTPS_DllAPI bool consistent(const MinimalMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:4954
RTPS_DllAPI MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:308
RTPS_DllAPI bool operator==(const MinimalMemberDetail &other) const
RTPS_DllAPI MinimalMemberDetail(MinimalMemberDetail &&x)
RTPS_DllAPI MinimalMemberDetail(const MinimalMemberDetail &x)
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:303
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition: TypeObject.h:291
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:297
RTPS_DllAPI bool consistent(const MinimalMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalSequenceType & operator=(const MinimalSequenceType &x)
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:4248
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:4214
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:4270
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:4275
RTPS_DllAPI MinimalSequenceType(const MinimalSequenceType &x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:4226
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:4253
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:4258
RTPS_DllAPI bool consistent(const MinimalSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:4231
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:4220
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:4242
RTPS_DllAPI bool operator==(const MinimalSequenceType &other) const
RTPS_DllAPI MinimalSequenceType(MinimalSequenceType &&x)
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:4264
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:4236
RTPS_DllAPI bool consistent(const MinimalStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:896
RTPS_DllAPI MinimalStructHeader(MinimalStructHeader &&x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:902
RTPS_DllAPI MinimalStructHeader & operator=(const MinimalStructHeader &x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:891
RTPS_DllAPI MinimalStructHeader(const MinimalStructHeader &x)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:886
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:908
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:874
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:913
RTPS_DllAPI bool operator==(const MinimalStructHeader &other) const
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:880
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:474
RTPS_DllAPI bool consistent(const MinimalStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:496
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:457
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:485
RTPS_DllAPI MinimalStructMember(MinimalStructMember &&x)
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:469
RTPS_DllAPI MinimalStructMember(const MinimalStructMember &x)
RTPS_DllAPI bool operator==(const MinimalStructMember &other) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:491
RTPS_DllAPI MinimalStructMember & operator=(const MinimalStructMember &x)
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:463
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:479
RTPS_DllAPI const MinimalStructHeader & header() const
Definition: TypeObject.h:1117
RTPS_DllAPI MinimalStructType & operator=(const MinimalStructType &x)
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:1089
RTPS_DllAPI MinimalStructType(MinimalStructType &&x)
RTPS_DllAPI void member_seq(const MinimalStructMemberSeq &_member_seq)
Definition: TypeObject.h:1127
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:1100
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:1083
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:1095
RTPS_DllAPI void header(const MinimalStructHeader &_header)
Definition: TypeObject.h:1105
RTPS_DllAPI void header(MinimalStructHeader &&_header)
Definition: TypeObject.h:1111
RTPS_DllAPI void member_seq(MinimalStructMemberSeq &&_member_seq)
Definition: TypeObject.h:1133
RTPS_DllAPI bool operator==(const MinimalStructType &other) const
RTPS_DllAPI const MinimalStructMemberSeq & member_seq() const
Definition: TypeObject.h:1139
RTPS_DllAPI MinimalStructType(const MinimalStructType &x)
RTPS_DllAPI MinimalStructMemberSeq & member_seq()
Definition: TypeObject.h:1144
RTPS_DllAPI bool consistent(const MinimalStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalStructHeader & header()
Definition: TypeObject.h:1122
RTPS_DllAPI MinimalTypeDetail(const MinimalTypeDetail &x)
RTPS_DllAPI MinimalTypeDetail(MinimalTypeDetail &&x)
RTPS_DllAPI MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
RTPS_DllAPI bool operator==(const MinimalTypeDetail &) const
Definition: TypeObject.h:635
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 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 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 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)
RTPS_DllAPI MinimalUnionType & union_type()
RTPS_DllAPI MinimalUnionHeader(MinimalUnionHeader &&x)
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:1881
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:1887
RTPS_DllAPI MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:1893
RTPS_DllAPI bool consistent(const MinimalUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const MinimalUnionHeader &other) const
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:1898
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:1441
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:1447
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:1480
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:1458
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:1469
RTPS_DllAPI MinimalUnionMember & operator=(const MinimalUnionMember &x)
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:1453
RTPS_DllAPI MinimalUnionMember(MinimalUnionMember &&x)
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:1475
RTPS_DllAPI bool operator==(const MinimalUnionMember &other) const
RTPS_DllAPI MinimalUnionMember(const MinimalUnionMember &x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:1463
Definition: TypeObject.h:2078
RTPS_DllAPI void member_seq(const MinimalUnionMemberSeq &_member_seq)
Definition: TypeObject.h:2158
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:2104
RTPS_DllAPI bool consistent(const MinimalUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void discriminator(const MinimalDiscriminatorMember &_discriminator)
Definition: TypeObject.h:2136
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:2109
RTPS_DllAPI void discriminator(MinimalDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:2142
RTPS_DllAPI MinimalUnionType(const MinimalUnionType &x)
RTPS_DllAPI bool operator==(const MinimalUnionType &other) const
RTPS_DllAPI const MinimalDiscriminatorMember & discriminator() const
Definition: TypeObject.h:2148
RTPS_DllAPI MinimalUnionType(MinimalUnionType &&x)
RTPS_DllAPI MinimalDiscriminatorMember & discriminator()
Definition: TypeObject.h:2153
RTPS_DllAPI MinimalUnionHeader & header()
Definition: TypeObject.h:2131
RTPS_DllAPI MinimalUnionType & operator=(const MinimalUnionType &x)
RTPS_DllAPI const MinimalUnionHeader & header() const
Definition: TypeObject.h:2126
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:2092
RTPS_DllAPI void member_seq(MinimalUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:2164
RTPS_DllAPI MinimalUnionMemberSeq & member_seq()
Definition: TypeObject.h:2175
RTPS_DllAPI const MinimalUnionMemberSeq & member_seq() const
Definition: TypeObject.h:2170
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:2098
RTPS_DllAPI void header(MinimalUnionHeader &&_header)
Definition: TypeObject.h:2120
RTPS_DllAPI void header(const MinimalUnionHeader &_header)
Definition: TypeObject.h:2114
Definition: TypesBase.h:500
Definition: TypeIdentifier.h:81
RTPS_DllAPI TypeIdentifier & type_identifier2()
Definition: TypeObject.h:7750
RTPS_DllAPI TypeIdentifierPair(TypeIdentifierPair &&x)
RTPS_DllAPI const TypeIdentifier & type_identifier1() const
Definition: TypeObject.h:7723
RTPS_DllAPI void type_identifier1(TypeIdentifier &&_type_identifier1)
Definition: TypeObject.h:7717
RTPS_DllAPI void type_identifier2(TypeIdentifier &&_type_identifier2)
Definition: TypeObject.h:7739
RTPS_DllAPI TypeIdentifier & type_identifier1()
Definition: TypeObject.h:7728
RTPS_DllAPI void type_identifier1(const TypeIdentifier &_type_identifier1)
Definition: TypeObject.h:7711
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:7733
RTPS_DllAPI const TypeIdentifier & type_identifier2() const
Definition: TypeObject.h:7745
RTPS_DllAPI void type_object(TypeObject &&_type_object)
Definition: TypeObject.h:7653
RTPS_DllAPI TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI TypeObject & type_object()
Definition: TypeObject.h:7664
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI void type_identifier(const TypeIdentifier &_type_identifier)
Definition: TypeObject.h:7625
RTPS_DllAPI const TypeObject & type_object() const
Definition: TypeObject.h:7659
RTPS_DllAPI void type_identifier(TypeIdentifier &&_type_identifier)
Definition: TypeObject.h:7631
RTPS_DllAPI void type_object(const TypeObject &_type_object)
Definition: TypeObject.h:7647
RTPS_DllAPI const TypeIdentifier & type_identifier() const
Definition: TypeObject.h:7637
RTPS_DllAPI TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI TypeIdentifier & type_identifier()
Definition: TypeObject.h:7642
RTPS_DllAPI const TypeIdentifierWithSize & typeid_with_size() const
Definition: TypeObject.h:7898
RTPS_DllAPI TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeid_with_size(const TypeIdentifierWithSize &_typeid_with_size)
Definition: TypeObject.h:7886
RTPS_DllAPI void typeid_with_size(TypeIdentifierWithSize &&_typeid_with_size)
Definition: TypeObject.h:7892
RTPS_DllAPI void dependent_typeids(const TypeIdentifierWithSizeSeq &_dependent_typeids)
Definition: TypeObject.h:7930
RTPS_DllAPI int32_t & dependent_typeid_count()
Definition: TypeObject.h:7925
RTPS_DllAPI void dependent_typeid_count(int32_t &&_dependent_typeid_count)
Definition: TypeObject.h:7914
RTPS_DllAPI const int32_t & dependent_typeid_count() const
Definition: TypeObject.h:7920
RTPS_DllAPI TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x)
RTPS_DllAPI void dependent_typeid_count(const int32_t &_dependent_typeid_count)
Definition: TypeObject.h:7908
RTPS_DllAPI const TypeIdentifierWithSizeSeq & dependent_typeids() const
Definition: TypeObject.h:7942
RTPS_DllAPI void dependent_typeids(TypeIdentifierWithSizeSeq &&_dependent_typeids)
Definition: TypeObject.h:7936
RTPS_DllAPI TypeIdentifierWithSize & typeid_with_size()
Definition: TypeObject.h:7903
RTPS_DllAPI TypeIdentifierWithSizeSeq & dependent_typeids()
Definition: TypeObject.h:7947
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeobject_serialized_size(uint32_t &&_typeobject_serialized_size)
Definition: TypeObject.h:7825
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:7803
RTPS_DllAPI TypeIdentifierWithSize(const TypeIdentifierWithSize &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:7814
RTPS_DllAPI const uint32_t & typeobject_serialized_size() const
Definition: TypeObject.h:7831
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:7797
RTPS_DllAPI TypeIdentifierWithSize(TypeIdentifierWithSize &&x)
RTPS_DllAPI uint32_t & typeobject_serialized_size()
Definition: TypeObject.h:7836
RTPS_DllAPI void typeobject_serialized_size(const uint32_t &_typeobject_serialized_size)
Definition: TypeObject.h:7819
RTPS_DllAPI TypeIdentifierWithSize & operator=(const TypeIdentifierWithSize &x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:7809
Definition: TypeObject.h:7986
RTPS_DllAPI void complete(TypeIdentifierWithDependencies &&_complete)
Definition: TypeObject.h:8028
RTPS_DllAPI void complete(const TypeIdentifierWithDependencies &_complete)
Definition: TypeObject.h:8022
RTPS_DllAPI const TypeIdentifierWithDependencies & minimal() const
Definition: TypeObject.h:8012
RTPS_DllAPI TypeIdentifierWithDependencies & minimal()
Definition: TypeObject.h:8017
RTPS_DllAPI const TypeIdentifierWithDependencies & complete() const
Definition: TypeObject.h:8034
RTPS_DllAPI void minimal(TypeIdentifierWithDependencies &&_minimal)
Definition: TypeObject.h:8006
RTPS_DllAPI TypeInformation(TypeInformation &&x)
RTPS_DllAPI TypeInformation & operator=(const TypeInformation &x)
RTPS_DllAPI void minimal(const TypeIdentifierWithDependencies &_minimal)
Definition: TypeObject.h:8000
RTPS_DllAPI TypeIdentifierWithDependencies & complete()
Definition: TypeObject.h:8039
RTPS_DllAPI TypeInformation(const TypeInformation &x)
Definition: TypeObject.h:7431
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.
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 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 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:6082
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition: TypeObject.h:6712
uint32_t MemberId
Definition: TypesBase.h:285
TypeObjectSeq StronglyConnectedComponent
Definition: TypeObject.h:7604
std::vector< TypeObject > TypeObjectSeq
Definition: TypeObject.h:7598
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition: TypeObject.h:6153
std::vector< int32_t > UnionCaseLabelSeq
Definition: TypeObject.h:1183
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition: TypeObject.h:6619
uint32_t LBound
Definition: TypesBase.h:294
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition: TypeObject.h:2540
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition: TypeObject.h:1515
std::string MemberName
Definition: TypesBase.h:166
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition: TypeObject.h:6151
std::vector< TypeIdentifierWithSize > TypeIdentifierWithSizeSeq
Definition: TypeObject.h:7863
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition: TypeObject.h:531
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition: TypeObject.h:7975
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition: TypeObject.h:5339
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition: TypeObject.h:2422
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition: TypeObject.h:7690
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition: TypeObject.h:5988
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition: TypeObject.h:435
std::vector< TypeInformation > TypeInformationSeq
Definition: TypeObject.h:8068
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition: TypeObject.h:5242
std::string QualifiedTypeName
Definition: TypesBase.h:171
uint16_t BitBound
Definition: TypeObject.h:5052
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition: TypeObject.h:1419
std::vector< LBound > LBoundSeq
Definition: TypesBase.h:295
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition: AnnotationParameterValue.h:1150
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition: TypeObject.h:7777
octet TypeKind
Definition: TypesBase.h:120
std::array< uint8_t, 4 > NameHash
Definition: TypesBase.h:179
eProsima namespace.
Definition: LibrarySettingsAttributes.h:23