libfastrtps-dev/api_reference/_type_object_8h_source.html

 // Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).

 //

 // Licensed under the Apache License, Version 2.0 (the "License");

 // you may not use this file except in compliance with the License.

 // You may obtain a copy of the License at

 //

 //     http://www.apache.org/licenses/LICENSE-2.0

 //

 // Unless required by applicable law or agreed to in writing, software

 // distributed under the License is distributed on an "AS IS" BASIS,

 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 // See the License for the specific language governing permissions and

 // limitations under the License.


 #ifndef TYPES_TYPE_OBJECT_H

 #define TYPES_TYPE_OBJECT_H


 #include <fastrtps/types/TypesBase.h>

 #include <fastrtps/types/TypeObjectHashId.h>

 #include <fastrtps/types/TypeIdentifier.h>

 #include <fastrtps/types/AnnotationParameterValue.h>

 #include <cstdint>

 #include <array>


 namespace eprosima {

 namespace fastcdr {

 class Cdr;

 }

 }


 // The types in this file shall be serialized with XCDR encoding version 2

 namespace eprosima {

 namespace fastrtps {


 namespace types {


 /*struct CommonStructMember final {

     MemberId                                   member_id;

     StructMemberFlag                           member_flags;

     TypeIdentifier                             member_type_id;

    };*/

 class CommonStructMember

 {

 public:


     RTPS_DllAPI CommonStructMember();

     RTPS_DllAPI ~CommonStructMember();

     RTPS_DllAPI CommonStructMember(

             const CommonStructMember& x);

     RTPS_DllAPI CommonStructMember(

             CommonStructMember&& x);

     RTPS_DllAPI CommonStructMember& operator=(

             const CommonStructMember& x);

     RTPS_DllAPI CommonStructMember& operator=(

             CommonStructMember&& x);


     RTPS_DllAPI inline void member_id(

             const MemberId& _member_id) { m_member_id = _member_id; }

     RTPS_DllAPI inline void member_id(

             MemberId&& _member_id) { m_member_id = std::move(_member_id); }

     RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }

     RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }


     RTPS_DllAPI inline void member_flags(

             const StructMemberFlag& _member_flags) { m_member_flags = _member_flags; }

     RTPS_DllAPI inline void member_flags(

             StructMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }

     RTPS_DllAPI inline const StructMemberFlag& member_flags() const { return m_member_flags; }

     RTPS_DllAPI inline StructMemberFlag& member_flags() { return m_member_flags; }


     RTPS_DllAPI inline void member_type_id(

             const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }

     RTPS_DllAPI inline void member_type_id(

             TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }

     RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }

     RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonStructMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonStructMember& other) const;


     RTPS_DllAPI bool consistent(

             const CommonStructMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     MemberId m_member_id;

     StructMemberFlag m_member_flags;

     TypeIdentifier m_member_type_id;

 };


 // COMPLETE Details for a member of an aggregate type

 /*struct CompleteMemberDetail final{

     MemberName                                 name;

     AppliedBuiltinMemberAnnotations  ann_builtin; // Optional

     AppliedAnnotationSeq             ann_custom; // Optional

    };*/

 class CompleteMemberDetail

 {

 public:


     RTPS_DllAPI CompleteMemberDetail();

     RTPS_DllAPI ~CompleteMemberDetail();

     RTPS_DllAPI CompleteMemberDetail(

             const CompleteMemberDetail& x);

     RTPS_DllAPI CompleteMemberDetail(

             CompleteMemberDetail&& x);

     RTPS_DllAPI CompleteMemberDetail& operator=(

             const CompleteMemberDetail& x);

     RTPS_DllAPI CompleteMemberDetail& operator=(

             CompleteMemberDetail&& x);


     RTPS_DllAPI inline void name(

             const MemberName& _name) { m_name = _name; }

     RTPS_DllAPI inline void name(

             MemberName&& _name) { m_name = std::move(_name); }

     RTPS_DllAPI inline const MemberName& name() const { return m_name; }

     RTPS_DllAPI inline MemberName& name() { return m_name; }


     RTPS_DllAPI inline void ann_builtin(

             const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }

     RTPS_DllAPI inline void ann_builtin(

             AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }

     RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }

     RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }


     RTPS_DllAPI inline void ann_custom(

             const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }

     RTPS_DllAPI inline void ann_custom(

             AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }

     RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }

     RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteMemberDetail& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteMemberDetail& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteMemberDetail& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     MemberName m_name;

     AppliedBuiltinMemberAnnotations m_ann_builtin;

     AppliedAnnotationSeq m_ann_custom;

 };


 // MINIMAL Details for a member of an aggregate type

 /*struct MinimalMemberDetail final{

     NameHash                                  name_hash;

    };*/


 class MinimalMemberDetail final

 {

 public:


     RTPS_DllAPI MinimalMemberDetail();

     RTPS_DllAPI ~MinimalMemberDetail();

     RTPS_DllAPI MinimalMemberDetail(

             const MinimalMemberDetail& x);

     RTPS_DllAPI MinimalMemberDetail(

             MinimalMemberDetail&& x);

     RTPS_DllAPI MinimalMemberDetail& operator=(

             const MinimalMemberDetail& x);

     RTPS_DllAPI MinimalMemberDetail& operator=(

             MinimalMemberDetail&& x);


     RTPS_DllAPI inline void name_hash(

             const NameHash& _name_hash) { m_name_hash = _name_hash; }

     RTPS_DllAPI inline void name_hash(

             NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }

     RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }

     RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalMemberDetail& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalMemberDetail& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalMemberDetail& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     NameHash m_name_hash;

 };


 // Member of an aggregate type

 /*struct CompleteStructMember {

     CommonStructMember                         common;

     CompleteMemberDetail                       detail;

    };*/

 class CompleteStructMember

 {

 public:


     RTPS_DllAPI CompleteStructMember();

     RTPS_DllAPI ~CompleteStructMember();

     RTPS_DllAPI CompleteStructMember(

             const CompleteStructMember& x);

     RTPS_DllAPI CompleteStructMember(

             CompleteStructMember&& x);

     RTPS_DllAPI CompleteStructMember& operator=(

             const CompleteStructMember& x);

     RTPS_DllAPI CompleteStructMember& operator=(

             CompleteStructMember&& x);


     RTPS_DllAPI inline void common(

             const CommonStructMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonStructMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonStructMember& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteStructMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteStructMember& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteStructMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonStructMember m_common;

     CompleteMemberDetail m_detail;

 };


 // Ordered by the member_index

 typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;


 // Member of an aggregate type

 /*struct MinimalStructMember {

     CommonStructMember                         common;

     MinimalMemberDetail                        detail;

    };*/

 class MinimalStructMember

 {

 public:


     RTPS_DllAPI MinimalStructMember();

     RTPS_DllAPI ~MinimalStructMember();

     RTPS_DllAPI MinimalStructMember(

             const MinimalStructMember& x);

     RTPS_DllAPI MinimalStructMember(

             MinimalStructMember&& x);

     RTPS_DllAPI MinimalStructMember& operator=(

             const MinimalStructMember& x);

     RTPS_DllAPI MinimalStructMember& operator=(

             MinimalStructMember&& x);


     RTPS_DllAPI inline void common(

             const CommonStructMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonStructMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonStructMember& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const MinimalMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalStructMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalStructMember& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalStructMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonStructMember m_common;

     MinimalMemberDetail m_detail;

 };


 // Ordered by common.member_id

 typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;


 /*struct AppliedBuiltinTypeAnnotations {

     AppliedVerbatimAnnotation verbatim;  // verbatim(...) // optional

    };*/

 class AppliedBuiltinTypeAnnotations

 {

 public:


     RTPS_DllAPI AppliedBuiltinTypeAnnotations();

     RTPS_DllAPI ~AppliedBuiltinTypeAnnotations();

     RTPS_DllAPI AppliedBuiltinTypeAnnotations(

             const AppliedBuiltinTypeAnnotations& x);

     RTPS_DllAPI AppliedBuiltinTypeAnnotations(

             AppliedBuiltinTypeAnnotations&& x);

     RTPS_DllAPI AppliedBuiltinTypeAnnotations& operator=(

             const AppliedBuiltinTypeAnnotations& x);

     RTPS_DllAPI AppliedBuiltinTypeAnnotations& operator=(

             AppliedBuiltinTypeAnnotations&& x);


     RTPS_DllAPI inline void verbatim(

             const AppliedVerbatimAnnotation& _verbatim) { m_verbatim = _verbatim; }

     RTPS_DllAPI inline void verbatim(

             AppliedVerbatimAnnotation&& _verbatim) { m_verbatim = std::move(_verbatim); }

     RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const { return m_verbatim; }

     RTPS_DllAPI inline AppliedVerbatimAnnotation& verbatim() { return m_verbatim; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const AppliedBuiltinTypeAnnotations& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const AppliedBuiltinTypeAnnotations& other) const;


     RTPS_DllAPI bool consistent(

             const AppliedBuiltinTypeAnnotations& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AppliedVerbatimAnnotation m_verbatim;

 };


 /*struct MinimalTypeDetail final{

     // Empty. Available for future extension

    };*/

 class MinimalTypeDetail

 {

 public:


     RTPS_DllAPI MinimalTypeDetail();

     RTPS_DllAPI ~MinimalTypeDetail();

     RTPS_DllAPI MinimalTypeDetail(

             const MinimalTypeDetail& x);

     RTPS_DllAPI MinimalTypeDetail(

             MinimalTypeDetail&& x);

     RTPS_DllAPI MinimalTypeDetail& operator=(

             const MinimalTypeDetail& x);

     RTPS_DllAPI MinimalTypeDetail& operator=(

             MinimalTypeDetail&& x);


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalTypeDetail& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalTypeDetail&) const { return true; }


     RTPS_DllAPI bool consistent(

             const MinimalTypeDetail& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


 };


 /*struct CompleteTypeDetail final{

     AppliedBuiltinTypeAnnotations  ann_builtin; // optional

     AppliedAnnotationSeq           ann_custom; // optional

     QualifiedTypeName                        type_name;

    };*/

 class CompleteTypeDetail

 {

 public:


     RTPS_DllAPI CompleteTypeDetail();

     RTPS_DllAPI ~CompleteTypeDetail();

     RTPS_DllAPI CompleteTypeDetail(

             const CompleteTypeDetail& x);

     RTPS_DllAPI CompleteTypeDetail(

             CompleteTypeDetail&& x);

     RTPS_DllAPI CompleteTypeDetail& operator=(

             const CompleteTypeDetail& x);

     RTPS_DllAPI CompleteTypeDetail& operator=(

             CompleteTypeDetail&& x);


     RTPS_DllAPI inline void ann_builtin(

             const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }

     RTPS_DllAPI inline void ann_builtin(

             AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }

     RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }

     RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }


     RTPS_DllAPI inline void ann_custom(

             const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }

     RTPS_DllAPI inline void ann_custom(

             AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }

     RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }

     RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }


     RTPS_DllAPI inline void type_name(

             const QualifiedTypeName& _type_name) { m_type_name = _type_name; }

     RTPS_DllAPI inline void type_name(

             QualifiedTypeName&& _type_name) { m_type_name = std::move(_type_name); }

     RTPS_DllAPI inline const QualifiedTypeName& type_name() const { return m_type_name; }

     RTPS_DllAPI inline QualifiedTypeName& type_name() { return m_type_name; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteTypeDetail& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteTypeDetail& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteTypeDetail& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AppliedBuiltinTypeAnnotations m_ann_builtin;

     AppliedAnnotationSeq m_ann_custom;

     QualifiedTypeName m_type_name;

 };

 /*struct CompleteStructHeader {

     TypeIdentifier                           base_type;

     CompleteTypeDetail                       detail;

    };*/

 class CompleteStructHeader

 {

 public:


     RTPS_DllAPI CompleteStructHeader();

     RTPS_DllAPI ~CompleteStructHeader();

     RTPS_DllAPI CompleteStructHeader(

             const CompleteStructHeader& x);

     RTPS_DllAPI CompleteStructHeader(

             CompleteStructHeader&& x);

     RTPS_DllAPI CompleteStructHeader& operator=(

             const CompleteStructHeader& x);

     RTPS_DllAPI CompleteStructHeader& operator=(

             CompleteStructHeader&& x);


     RTPS_DllAPI inline void base_type(

             const TypeIdentifier& _base_type) { m_base_type = _base_type; }

     RTPS_DllAPI inline void base_type(

             TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }

     RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }

     RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteStructHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteStructHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteStructHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     TypeIdentifier m_base_type;

     CompleteTypeDetail m_detail;

 };

 /*struct MinimalStructHeader {

     TypeIdentifier                           base_type;

     MinimalTypeDetail                        detail;

    };*/

 class MinimalStructHeader

 {

 public:


     RTPS_DllAPI MinimalStructHeader();

     RTPS_DllAPI ~MinimalStructHeader();

     RTPS_DllAPI MinimalStructHeader(

             const MinimalStructHeader& x);

     RTPS_DllAPI MinimalStructHeader(

             MinimalStructHeader&& x);

     RTPS_DllAPI MinimalStructHeader& operator=(

             const MinimalStructHeader& x);

     RTPS_DllAPI MinimalStructHeader& operator=(

             MinimalStructHeader&& x);


     RTPS_DllAPI inline void base_type(

             const TypeIdentifier& _base_type) { m_base_type = _base_type; }

     RTPS_DllAPI inline void base_type(

             TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }

     RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }

     RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }


     RTPS_DllAPI inline void detail(

             const MinimalTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalStructHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalStructHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalStructHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     TypeIdentifier m_base_type;

     MinimalTypeDetail m_detail;

 };


 /*struct CompleteStructType final{

     StructTypeFlag             struct_flags;

     CompleteStructHeader       header;

     CompleteStructMemberSeq    member_seq;

    };*/

 class CompleteStructType

 {

 public:


     RTPS_DllAPI CompleteStructType();

     RTPS_DllAPI ~CompleteStructType();

     RTPS_DllAPI CompleteStructType(

             const CompleteStructType& x);

     RTPS_DllAPI CompleteStructType(

             CompleteStructType&& x);

     RTPS_DllAPI CompleteStructType& operator=(

             const CompleteStructType& x);

     RTPS_DllAPI CompleteStructType& operator=(

             CompleteStructType&& x);


     RTPS_DllAPI inline void struct_flags(

             const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }

     RTPS_DllAPI inline void struct_flags(

             StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }

     RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }

     RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }


     RTPS_DllAPI inline void header(

             const CompleteStructHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteStructHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteStructHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteStructHeader& header() { return m_header; }


     RTPS_DllAPI inline void member_seq(

             const CompleteStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             CompleteStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline CompleteStructMemberSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteStructType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteStructType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteStructType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     StructTypeFlag m_struct_flags;

     CompleteStructHeader m_header;

     CompleteStructMemberSeq m_member_seq;

 };


 /*struct MinimalStructType final{

     StructTypeFlag             struct_flags;

     MinimalStructHeader        header;

     MinimalStructMemberSeq     member_seq;

    };*/

 class MinimalStructType

 {

 public:


     RTPS_DllAPI MinimalStructType();

     RTPS_DllAPI ~MinimalStructType();

     RTPS_DllAPI MinimalStructType(

             const MinimalStructType& x);

     RTPS_DllAPI MinimalStructType(

             MinimalStructType&& x);

     RTPS_DllAPI MinimalStructType& operator=(

             const MinimalStructType& x);

     RTPS_DllAPI MinimalStructType& operator=(

             MinimalStructType&& x);


     RTPS_DllAPI inline void struct_flags(

             const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }

     RTPS_DllAPI inline void struct_flags(

             StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }

     RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }

     RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }


     RTPS_DllAPI inline void header(

             const MinimalStructHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalStructHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalStructHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalStructHeader& header() { return m_header; }


     RTPS_DllAPI inline void member_seq(

             const MinimalStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             MinimalStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline MinimalStructMemberSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalStructType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalStructType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalStructType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     StructTypeFlag m_struct_flags;

     MinimalStructHeader m_header;

     MinimalStructMemberSeq m_member_seq;

 };


 // --- Union: ---------------------------------------------------------


 // Case labels that apply to a member of a union type

 // Ordered by their values

 typedef std::vector<int32_t> UnionCaseLabelSeq;


 /*struct CommonUnionMember final{

     MemberId                    member_id;

     UnionMemberFlag             member_flags;

     TypeIdentifier              type_id;

     UnionCaseLabelSeq           label_seq;

    };*/

 class CommonUnionMember

 {

 public:


     RTPS_DllAPI CommonUnionMember();

     RTPS_DllAPI ~CommonUnionMember();

     RTPS_DllAPI CommonUnionMember(

             const CommonUnionMember& x);

     RTPS_DllAPI CommonUnionMember(

             CommonUnionMember&& x);

     RTPS_DllAPI CommonUnionMember& operator=(

             const CommonUnionMember& x);

     RTPS_DllAPI CommonUnionMember& operator=(

             CommonUnionMember&& x);


     RTPS_DllAPI inline void member_id(

             const MemberId& _member_id) { m_member_id = _member_id; }

     RTPS_DllAPI inline void member_id(

             MemberId&& _member_id) { m_member_id = std::move(_member_id); }

     RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }

     RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }


     RTPS_DllAPI inline void member_flags(

             const UnionMemberFlag& _member_flags) { m_member_flags = _member_flags; }

     RTPS_DllAPI inline void member_flags(

             UnionMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }

     RTPS_DllAPI inline const UnionMemberFlag& member_flags() const { return m_member_flags; }

     RTPS_DllAPI inline UnionMemberFlag& member_flags() { return m_member_flags; }


     RTPS_DllAPI inline void type_id(

             const TypeIdentifier& _type_id) { m_type_id = _type_id; }

     RTPS_DllAPI inline void type_id(

             TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }

     RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }

     RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }


     RTPS_DllAPI inline void label_seq(

             const UnionCaseLabelSeq& _label_seq) { m_label_seq = _label_seq; }

     RTPS_DllAPI inline void label_seq(

             UnionCaseLabelSeq&& _label_seq) { m_label_seq = std::move(_label_seq); }

     RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const { return m_label_seq; }

     RTPS_DllAPI inline UnionCaseLabelSeq& label_seq() { return m_label_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonUnionMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonUnionMember& other) const;


     RTPS_DllAPI bool consistent(

             const CommonUnionMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     MemberId m_member_id;

     UnionMemberFlag m_member_flags;

     TypeIdentifier m_type_id;

     UnionCaseLabelSeq m_label_seq;

 };


 // Member of a union type

 /*struct CompleteUnionMember {

     CommonUnionMember      common;

     CompleteMemberDetail   detail;

    };*/

 class CompleteUnionMember

 {

 public:


     RTPS_DllAPI CompleteUnionMember();

     RTPS_DllAPI ~CompleteUnionMember();

     RTPS_DllAPI CompleteUnionMember(

             const CompleteUnionMember& x);

     RTPS_DllAPI CompleteUnionMember(

             CompleteUnionMember&& x);

     RTPS_DllAPI CompleteUnionMember& operator=(

             const CompleteUnionMember& x);

     RTPS_DllAPI CompleteUnionMember& operator=(

             CompleteUnionMember&& x);


     RTPS_DllAPI inline void common(

             const CommonUnionMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonUnionMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteUnionMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteUnionMember& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteUnionMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonUnionMember m_common;

     CompleteMemberDetail m_detail;

 };


 // Ordered by member_index

 typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;


 // Member of a union type

 /*struct MinimalUnionMember {

     CommonUnionMember   common;

     MinimalMemberDetail detail;

    };*/

 class MinimalUnionMember

 {

 public:


     RTPS_DllAPI MinimalUnionMember();

     RTPS_DllAPI ~MinimalUnionMember();

     RTPS_DllAPI MinimalUnionMember(

             const MinimalUnionMember& x);

     RTPS_DllAPI MinimalUnionMember(

             MinimalUnionMember&& x);

     RTPS_DllAPI MinimalUnionMember& operator=(

             const MinimalUnionMember& x);

     RTPS_DllAPI MinimalUnionMember& operator=(

             MinimalUnionMember&& x);


     RTPS_DllAPI inline void common(

             const CommonUnionMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonUnionMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const MinimalMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalUnionMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalUnionMember& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalUnionMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonUnionMember m_common;

     MinimalMemberDetail m_detail;

 };


 // Ordered by MinimalUnionMember.common.member_id

 typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;


 /*struct CommonDiscriminatorMember final{

     UnionDiscriminatorFlag       member_flags;

     TypeIdentifier               type_id;

    };*/

 class CommonDiscriminatorMember

 {

 public:


     RTPS_DllAPI CommonDiscriminatorMember();

     RTPS_DllAPI ~CommonDiscriminatorMember();

     RTPS_DllAPI CommonDiscriminatorMember(

             const CommonDiscriminatorMember& x);

     RTPS_DllAPI CommonDiscriminatorMember(

             CommonDiscriminatorMember&& x);

     RTPS_DllAPI CommonDiscriminatorMember& operator=(

             const CommonDiscriminatorMember& x);

     RTPS_DllAPI CommonDiscriminatorMember& operator=(

             CommonDiscriminatorMember&& x);


     RTPS_DllAPI inline void member_flags(

             const UnionDiscriminatorFlag& _member_flags) { m_member_flags = _member_flags; }

     RTPS_DllAPI inline void member_flags(

             UnionDiscriminatorFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }

     RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const { return m_member_flags; }

     RTPS_DllAPI inline UnionDiscriminatorFlag& member_flags() { return m_member_flags; }


     RTPS_DllAPI inline void type_id(

             const TypeIdentifier& _type_id) { m_type_id = _type_id; }

     RTPS_DllAPI inline void type_id(

             TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }

     RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }

     RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonDiscriminatorMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonDiscriminatorMember& other) const;


     RTPS_DllAPI bool consistent(

             const CommonDiscriminatorMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     UnionDiscriminatorFlag m_member_flags;

     TypeIdentifier m_type_id;

 };


 // Member of a union type

 /*struct CompleteDiscriminatorMember {

     CommonDiscriminatorMember                common;

     AppliedBuiltinTypeAnnotations  ann_builtin; // Optional

     AppliedAnnotationSeq           ann_custom; // Optional

    };*/

 class CompleteDiscriminatorMember

 {

 public:


     RTPS_DllAPI CompleteDiscriminatorMember();

     RTPS_DllAPI ~CompleteDiscriminatorMember();

     RTPS_DllAPI CompleteDiscriminatorMember(

             const CompleteDiscriminatorMember& x);

     RTPS_DllAPI CompleteDiscriminatorMember(

             CompleteDiscriminatorMember&& x);

     RTPS_DllAPI CompleteDiscriminatorMember& operator=(

             const CompleteDiscriminatorMember& x);

     RTPS_DllAPI CompleteDiscriminatorMember& operator=(

             CompleteDiscriminatorMember&& x);


     RTPS_DllAPI inline void common(

             const CommonDiscriminatorMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }


     RTPS_DllAPI inline void ann_builtin(

             const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }

     RTPS_DllAPI inline void ann_builtin(

             AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }

     RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }

     RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }


     RTPS_DllAPI inline void ann_custom(

             const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }

     RTPS_DllAPI inline void ann_custom(

             AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }

     RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }

     RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteDiscriminatorMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteDiscriminatorMember& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteDiscriminatorMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonDiscriminatorMember m_common;

     AppliedBuiltinTypeAnnotations m_ann_builtin;

     AppliedAnnotationSeq m_ann_custom;

 };


 // Member of a union type

 /*struct MinimalDiscriminatorMember {

     CommonDiscriminatorMember   common;

    };*/

 class MinimalDiscriminatorMember

 {

 public:


     RTPS_DllAPI MinimalDiscriminatorMember();

     RTPS_DllAPI ~MinimalDiscriminatorMember();

     RTPS_DllAPI MinimalDiscriminatorMember(

             const MinimalDiscriminatorMember& x);

     RTPS_DllAPI MinimalDiscriminatorMember(

             MinimalDiscriminatorMember&& x);

     RTPS_DllAPI MinimalDiscriminatorMember& operator=(

             const MinimalDiscriminatorMember& x);

     RTPS_DllAPI MinimalDiscriminatorMember& operator=(

             MinimalDiscriminatorMember&& x);


     RTPS_DllAPI inline void common(

             const CommonDiscriminatorMember& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }

     RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalDiscriminatorMember& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalDiscriminatorMember& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalDiscriminatorMember& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonDiscriminatorMember m_common;

 };


 /*struct CompleteUnionHeader {

     CompleteTypeDetail          detail;

    };*/

 class CompleteUnionHeader

 {

 public:


     RTPS_DllAPI CompleteUnionHeader();

     RTPS_DllAPI ~CompleteUnionHeader();

     RTPS_DllAPI CompleteUnionHeader(

             const CompleteUnionHeader& x);

     RTPS_DllAPI CompleteUnionHeader(

             CompleteUnionHeader&& x);

     RTPS_DllAPI CompleteUnionHeader& operator=(

             const CompleteUnionHeader& x);

     RTPS_DllAPI CompleteUnionHeader& operator=(

             CompleteUnionHeader&& x);


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteUnionHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteUnionHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteUnionHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CompleteTypeDetail m_detail;

 };


 /*struct MinimalUnionHeader {

     MinimalTypeDetail           detail;

    };*/

 class MinimalUnionHeader

 {

 public:


     RTPS_DllAPI MinimalUnionHeader();

     RTPS_DllAPI ~MinimalUnionHeader();

     RTPS_DllAPI MinimalUnionHeader(

             const MinimalUnionHeader& x);

     RTPS_DllAPI MinimalUnionHeader(

             MinimalUnionHeader&& x);

     RTPS_DllAPI MinimalUnionHeader& operator=(

             const MinimalUnionHeader& x);

     RTPS_DllAPI MinimalUnionHeader& operator=(

             MinimalUnionHeader&& x);


     RTPS_DllAPI inline void detail(

             const MinimalTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalUnionHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalUnionHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalUnionHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     MinimalTypeDetail m_detail;

 };


 /*struct CompleteUnionType final{

     UnionTypeFlag                union_flags;

     CompleteUnionHeader          header;

     CompleteDiscriminatorMember  discriminator;

     CompleteUnionMemberSeq       member_seq;

    };*/

 class CompleteUnionType

 {

 public:


     RTPS_DllAPI CompleteUnionType();

     RTPS_DllAPI ~CompleteUnionType();

     RTPS_DllAPI CompleteUnionType(

             const CompleteUnionType& x);

     RTPS_DllAPI CompleteUnionType(

             CompleteUnionType&& x);

     RTPS_DllAPI CompleteUnionType& operator=(

             const CompleteUnionType& x);

     RTPS_DllAPI CompleteUnionType& operator=(

             CompleteUnionType&& x);


     RTPS_DllAPI inline void union_flags(

             const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }

     RTPS_DllAPI inline void union_flags(

             UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }

     RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }

     RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }


     RTPS_DllAPI inline void header(

             const CompleteUnionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteUnionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteUnionHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteUnionHeader& header() { return m_header; }


     RTPS_DllAPI inline void discriminator(

             const CompleteDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }

     RTPS_DllAPI inline void discriminator(

             CompleteDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }

     RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const { return m_discriminator; }

     RTPS_DllAPI inline CompleteDiscriminatorMember& discriminator() { return m_discriminator; }


     RTPS_DllAPI inline void member_seq(

             const CompleteUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             CompleteUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline CompleteUnionMemberSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteUnionType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteUnionType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteUnionType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     UnionTypeFlag m_union_flags;

     CompleteUnionHeader m_header;

     CompleteDiscriminatorMember m_discriminator;

     CompleteUnionMemberSeq m_member_seq;

 };


 /*struct MinimalUnionType final{

     UnionTypeFlag                union_flags;

     MinimalUnionHeader           header;

     MinimalDiscriminatorMember   discriminator;

     MinimalUnionMemberSeq        member_seq;

    };*/

 class MinimalUnionType

 {

 public:


     RTPS_DllAPI MinimalUnionType();

     RTPS_DllAPI ~MinimalUnionType();

     RTPS_DllAPI MinimalUnionType(

             const MinimalUnionType& x);

     RTPS_DllAPI MinimalUnionType(

             MinimalUnionType&& x);

     RTPS_DllAPI MinimalUnionType& operator=(

             const MinimalUnionType& x);

     RTPS_DllAPI MinimalUnionType& operator=(

             MinimalUnionType&& x);


     RTPS_DllAPI inline void union_flags(

             const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }

     RTPS_DllAPI inline void union_flags(

             UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }

     RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }

     RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }


     RTPS_DllAPI inline void header(

             const MinimalUnionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalUnionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalUnionHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalUnionHeader& header() { return m_header; }


     RTPS_DllAPI inline void discriminator(

             const MinimalDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }

     RTPS_DllAPI inline void discriminator(

             MinimalDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }

     RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const { return m_discriminator; }

     RTPS_DllAPI inline MinimalDiscriminatorMember& discriminator() { return m_discriminator; }


     RTPS_DllAPI inline void member_seq(

             const MinimalUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             MinimalUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalUnionType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalUnionType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalUnionType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     UnionTypeFlag m_union_flags;

     MinimalUnionHeader m_header;

     MinimalDiscriminatorMember m_discriminator;

     MinimalUnionMemberSeq m_member_seq;

 };


 // --- Annotation: ---------------------------------------------------

 /*struct CommonAnnotationParameter final{

     AnnotationParameterFlag      member_flags;

     TypeIdentifier               member_type_id;

    };*/

 class CommonAnnotationParameter

 {

 public:


     RTPS_DllAPI CommonAnnotationParameter();

     RTPS_DllAPI ~CommonAnnotationParameter();

     RTPS_DllAPI CommonAnnotationParameter(

             const CommonAnnotationParameter& x);

     RTPS_DllAPI CommonAnnotationParameter(

             CommonAnnotationParameter&& x);

     RTPS_DllAPI CommonAnnotationParameter& operator=(

             const CommonAnnotationParameter& x);

     RTPS_DllAPI CommonAnnotationParameter& operator=(

             CommonAnnotationParameter&& x);


     RTPS_DllAPI inline void member_flags(

             const AnnotationParameterFlag& _member_flags) { m_member_flags = _member_flags; }

     RTPS_DllAPI inline void member_flags(

             AnnotationParameterFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }

     RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const { return m_member_flags; }

     RTPS_DllAPI inline AnnotationParameterFlag& member_flags() { return m_member_flags; }


     RTPS_DllAPI inline void member_type_id(

             const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }

     RTPS_DllAPI inline void member_type_id(

             TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }

     RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }

     RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonAnnotationParameter& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonAnnotationParameter& other) const;


     RTPS_DllAPI bool consistent(

             const CommonAnnotationParameter& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AnnotationParameterFlag m_member_flags;

     TypeIdentifier m_member_type_id;

 };


 // Member of an annotation type


 /*struct CompleteAnnotationParameter {

     CommonAnnotationParameter  common;

     MemberName                 name;

     AnnotationParameterValue   default_value;

    };*/

 class CompleteAnnotationParameter

 {

 public:


     RTPS_DllAPI CompleteAnnotationParameter();

     RTPS_DllAPI ~CompleteAnnotationParameter();

     RTPS_DllAPI CompleteAnnotationParameter(

             const CompleteAnnotationParameter& x);

     RTPS_DllAPI CompleteAnnotationParameter(

             CompleteAnnotationParameter&& x);

     RTPS_DllAPI CompleteAnnotationParameter& operator=(

             const CompleteAnnotationParameter& x);

     RTPS_DllAPI CompleteAnnotationParameter& operator=(

             CompleteAnnotationParameter&& x);


     RTPS_DllAPI inline void common(

             const CommonAnnotationParameter& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonAnnotationParameter&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }

     RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }


     RTPS_DllAPI inline void name(

             const MemberName& _name) { m_name = _name; }

     RTPS_DllAPI inline void name(

             MemberName&& _name) { m_name = std::move(_name); }

     RTPS_DllAPI inline const MemberName& name() const { return m_name; }

     RTPS_DllAPI inline MemberName& name() { return m_name; }


     RTPS_DllAPI inline void default_value(

             const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }

     RTPS_DllAPI inline void default_value(

             AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }

     RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }

     RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAnnotationParameter& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAnnotationParameter& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteAnnotationParameter& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonAnnotationParameter m_common;

     MemberName m_name;

     AnnotationParameterValue m_default_value;

 };

 // Ordered by CompleteAnnotationParameter.name

 typedef    std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;

 /*struct MinimalAnnotationParameter {

     CommonAnnotationParameter  common;

     NameHash                   name_hash;

     AnnotationParameterValue   default_value;

    };*/

 class MinimalAnnotationParameter

 {

 public:


     RTPS_DllAPI MinimalAnnotationParameter();

     RTPS_DllAPI ~MinimalAnnotationParameter();

     RTPS_DllAPI MinimalAnnotationParameter(

             const MinimalAnnotationParameter& x);

     RTPS_DllAPI MinimalAnnotationParameter(

             MinimalAnnotationParameter&& x);

     RTPS_DllAPI MinimalAnnotationParameter& operator=(

             const MinimalAnnotationParameter& x);

     RTPS_DllAPI MinimalAnnotationParameter& operator=(

             MinimalAnnotationParameter&& x);


     RTPS_DllAPI inline void common(

             const CommonAnnotationParameter& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonAnnotationParameter&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }

     RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }


     RTPS_DllAPI inline void name(

             const MemberName& _name) { m_name = _name; }

     RTPS_DllAPI inline void name(

             MemberName&& _name) { m_name = std::move(_name); }

     RTPS_DllAPI inline const MemberName& name() const { return m_name; }

     RTPS_DllAPI inline MemberName& name() { return m_name; }


     RTPS_DllAPI inline void default_value(

             const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }

     RTPS_DllAPI inline void default_value(

             AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }

     RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }

     RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAnnotationParameter& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAnnotationParameter& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalAnnotationParameter& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonAnnotationParameter m_common;

     MemberName m_name;

     AnnotationParameterValue m_default_value;

 };


 // Ordered by MinimalAnnotationParameter.name_hash

 typedef    std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;

 /*struct CompleteAnnotationHeader {

     QualifiedTypeName         annotation_name;

    };*/

 class CompleteAnnotationHeader

 {

 public:


     RTPS_DllAPI CompleteAnnotationHeader();

     RTPS_DllAPI ~CompleteAnnotationHeader();

     RTPS_DllAPI CompleteAnnotationHeader(

             const CompleteAnnotationHeader& x);

     RTPS_DllAPI CompleteAnnotationHeader(

             CompleteAnnotationHeader&& x);

     RTPS_DllAPI CompleteAnnotationHeader& operator=(

             const CompleteAnnotationHeader& x);

     RTPS_DllAPI CompleteAnnotationHeader& operator=(

             CompleteAnnotationHeader&& x);


     RTPS_DllAPI inline void annotation_name(

             const QualifiedTypeName& _annotation_name) { m_annotation_name = _annotation_name; }

     RTPS_DllAPI inline void annotation_name(

             QualifiedTypeName&& _annotation_name) { m_annotation_name = std::move(_annotation_name); }

     RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const { return m_annotation_name; }

     RTPS_DllAPI inline QualifiedTypeName& annotation_name() { return m_annotation_name; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAnnotationHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAnnotationHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteAnnotationHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     QualifiedTypeName m_annotation_name;

 };


 /*struct MinimalAnnotationHeader {

     // Empty. Available for future extension

    };*/

 class MinimalAnnotationHeader

 {

 public:


     RTPS_DllAPI MinimalAnnotationHeader();

     RTPS_DllAPI ~MinimalAnnotationHeader();

     RTPS_DllAPI MinimalAnnotationHeader(

             const MinimalAnnotationHeader& x);

     RTPS_DllAPI MinimalAnnotationHeader(

             MinimalAnnotationHeader&& x);

     RTPS_DllAPI MinimalAnnotationHeader& operator=(

             const MinimalAnnotationHeader& x);

     RTPS_DllAPI MinimalAnnotationHeader& operator=(

             MinimalAnnotationHeader&& x);


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAnnotationHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAnnotationHeader&) const { return true; }


     RTPS_DllAPI bool consistent(

             const MinimalAnnotationHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


 };


 /*struct CompleteAnnotationType final{

     AnnotationTypeFlag             annotation_flag;

     CompleteAnnotationHeader       header;

     CompleteAnnotationParameterSeq member_seq;

    };*/

 class CompleteAnnotationType final

 {

 public:


     RTPS_DllAPI CompleteAnnotationType();

     RTPS_DllAPI ~CompleteAnnotationType();

     RTPS_DllAPI CompleteAnnotationType(

             const CompleteAnnotationType& x);

     RTPS_DllAPI CompleteAnnotationType(

             CompleteAnnotationType&& x);

     RTPS_DllAPI CompleteAnnotationType& operator=(

             const CompleteAnnotationType& x);

     RTPS_DllAPI CompleteAnnotationType& operator=(

             CompleteAnnotationType&& x);


     RTPS_DllAPI inline void annotation_flag(

             const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }

     RTPS_DllAPI inline void annotation_flag(

             AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }

     RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }

     RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }


     RTPS_DllAPI inline void header(

             const CompleteAnnotationHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteAnnotationHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteAnnotationHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteAnnotationHeader& header() { return m_header; }


     RTPS_DllAPI inline void member_seq(

             const CompleteAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             CompleteAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline CompleteAnnotationParameterSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAnnotationType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAnnotationType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteAnnotationType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AnnotationTypeFlag m_annotation_flag;

     CompleteAnnotationHeader m_header;

     CompleteAnnotationParameterSeq m_member_seq;

 };

 /*struct MinimalAnnotationType final{

     AnnotationTypeFlag             annotation_flag;

     MinimalAnnotationHeader        header;

     MinimalAnnotationParameterSeq  member_seq;

    };*/

 class MinimalAnnotationType final

 {

 public:


     RTPS_DllAPI MinimalAnnotationType();

     RTPS_DllAPI ~MinimalAnnotationType();

     RTPS_DllAPI MinimalAnnotationType(

             const MinimalAnnotationType& x);

     RTPS_DllAPI MinimalAnnotationType(

             MinimalAnnotationType&& x);

     RTPS_DllAPI MinimalAnnotationType& operator=(

             const MinimalAnnotationType& x);

     RTPS_DllAPI MinimalAnnotationType& operator=(

             MinimalAnnotationType&& x);


     RTPS_DllAPI inline void annotation_flag(

             const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }

     RTPS_DllAPI inline void annotation_flag(

             AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }

     RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }

     RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }


     RTPS_DllAPI inline void header(

             const MinimalAnnotationHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalAnnotationHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalAnnotationHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalAnnotationHeader& header() { return m_header; }


     RTPS_DllAPI inline void member_seq(

             const MinimalAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }

     RTPS_DllAPI inline void member_seq(

             MinimalAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }

     RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const { return m_member_seq; }

     RTPS_DllAPI inline MinimalAnnotationParameterSeq& member_seq() { return m_member_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAnnotationType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAnnotationType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalAnnotationType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AnnotationTypeFlag m_annotation_flag;

     MinimalAnnotationHeader m_header;

     MinimalAnnotationParameterSeq m_member_seq;

 };


 // --- Alias: ---------------------------------------------------------

 /*struct CommonAliasBody final{

     AliasMemberFlag       related_flags;

     TypeIdentifier        related_type;

    };*/

 class CommonAliasBody

 {

 public:


     RTPS_DllAPI CommonAliasBody();

     RTPS_DllAPI ~CommonAliasBody();

     RTPS_DllAPI CommonAliasBody(

             const CommonAliasBody& x);

     RTPS_DllAPI CommonAliasBody(

             CommonAliasBody&& x);

     RTPS_DllAPI CommonAliasBody& operator=(

             const CommonAliasBody& x);

     RTPS_DllAPI CommonAliasBody& operator=(

             CommonAliasBody&& x);


     RTPS_DllAPI inline void related_flags(

             const AliasMemberFlag& _related_flags) { m_related_flags = _related_flags; }

     RTPS_DllAPI inline void related_flags(

             AliasMemberFlag&& _related_flags) { m_related_flags = std::move(_related_flags); }

     RTPS_DllAPI inline const AliasMemberFlag& related_flags() const { return m_related_flags; }

     RTPS_DllAPI inline AliasMemberFlag& related_flags() { return m_related_flags; }


     RTPS_DllAPI inline void related_type(

             const TypeIdentifier& _related_type) { m_related_type = _related_type; }

     RTPS_DllAPI inline void related_type(

             TypeIdentifier&& _related_type) { m_related_type = std::move(_related_type); }

     RTPS_DllAPI inline const TypeIdentifier& related_type() const { return m_related_type; }

     RTPS_DllAPI inline TypeIdentifier& related_type() { return m_related_type; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonAliasBody& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonAliasBody& other) const;


     //    RTPS_DllAPI bool consistent(const CommonAliasBody &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AliasMemberFlag m_related_flags;

     TypeIdentifier m_related_type;

 };


 /*struct CompleteAliasBody {

     CommonAliasBody       common;

     AppliedBuiltinMemberAnnotations  ann_builtin; // Optional

     AppliedAnnotationSeq             ann_custom; // Optional

    };*/

 class CompleteAliasBody

 {

 public:


     RTPS_DllAPI CompleteAliasBody();

     RTPS_DllAPI ~CompleteAliasBody();

     RTPS_DllAPI CompleteAliasBody(

             const CompleteAliasBody& x);

     RTPS_DllAPI CompleteAliasBody(

             CompleteAliasBody&& x);

     RTPS_DllAPI CompleteAliasBody& operator=(

             const CompleteAliasBody& x);

     RTPS_DllAPI CompleteAliasBody& operator=(

             CompleteAliasBody&& x);


     RTPS_DllAPI inline void common(

             const CommonAliasBody& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonAliasBody&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }

     RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }


     RTPS_DllAPI inline void ann_builtin(

             const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }

     RTPS_DllAPI inline void ann_builtin(

             AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }

     RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }

     RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }


     RTPS_DllAPI inline void ann_custom(

             const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }

     RTPS_DllAPI inline void ann_custom(

             AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }

     RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }

     RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAliasBody& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAliasBody& other) const;


     //    RTPS_DllAPI bool consistent(const CompleteAliasBody &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonAliasBody m_common;

     AppliedBuiltinMemberAnnotations m_ann_builtin;

     AppliedAnnotationSeq m_ann_custom;

 };


 /*struct MinimalAliasBody {

     CommonAliasBody       common;

    };*/

 class MinimalAliasBody

 {

 public:


     RTPS_DllAPI MinimalAliasBody();

     RTPS_DllAPI ~MinimalAliasBody();

     RTPS_DllAPI MinimalAliasBody(

             const MinimalAliasBody& x);

     RTPS_DllAPI MinimalAliasBody(

             MinimalAliasBody&& x);

     RTPS_DllAPI MinimalAliasBody& operator=(

             const MinimalAliasBody& x);

     RTPS_DllAPI MinimalAliasBody& operator=(

             MinimalAliasBody&& x);


     RTPS_DllAPI inline void common(

             const CommonAliasBody& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonAliasBody&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }

     RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAliasBody& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAliasBody& other) const;


     //    RTPS_DllAPI bool consistent(const MinimalAliasBody &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonAliasBody m_common;

 };


 /*struct CompleteAliasHeader {

     CompleteTypeDetail    detail;

    };*/

 class CompleteAliasHeader

 {

 public:


     RTPS_DllAPI CompleteAliasHeader();

     RTPS_DllAPI ~CompleteAliasHeader();

     RTPS_DllAPI CompleteAliasHeader(

             const CompleteAliasHeader& x);

     RTPS_DllAPI CompleteAliasHeader(

             CompleteAliasHeader&& x);

     RTPS_DllAPI CompleteAliasHeader& operator=(

             const CompleteAliasHeader& x);

     RTPS_DllAPI CompleteAliasHeader& operator=(

             CompleteAliasHeader&& x);


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAliasHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAliasHeader& other) const;


     //    RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CompleteTypeDetail m_detail;

 };


 /*struct MinimalAliasHeader {

     // Empty. Available for future extension

    };*/

 class MinimalAliasHeader

 {

 public:


     RTPS_DllAPI MinimalAliasHeader();

     RTPS_DllAPI ~MinimalAliasHeader();

     RTPS_DllAPI MinimalAliasHeader(

             const MinimalAliasHeader& x);

     RTPS_DllAPI MinimalAliasHeader(

             MinimalAliasHeader&& x);

     RTPS_DllAPI MinimalAliasHeader& operator=(

             const MinimalAliasHeader& x);

     RTPS_DllAPI MinimalAliasHeader& operator=(

             MinimalAliasHeader&& x);


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAliasHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAliasHeader&) const { return true; }


     //    RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


 };


 /*struct CompleteAliasType final{

     AliasTypeFlag         alias_flags;

     CompleteAliasHeader   header;

     CompleteAliasBody     body;

    };*/

 class CompleteAliasType

 {

 public:


     RTPS_DllAPI CompleteAliasType();

     RTPS_DllAPI ~CompleteAliasType();

     RTPS_DllAPI CompleteAliasType(

             const CompleteAliasType& x);

     RTPS_DllAPI CompleteAliasType(

             CompleteAliasType&& x);

     RTPS_DllAPI CompleteAliasType& operator=(

             const CompleteAliasType& x);

     RTPS_DllAPI CompleteAliasType& operator=(

             CompleteAliasType&& x);


     RTPS_DllAPI inline void alias_flags(

             const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }

     RTPS_DllAPI inline void alias_flags(

             AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }

     RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }

     RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }


     RTPS_DllAPI inline void header(

             const CompleteAliasHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteAliasHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteAliasHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteAliasHeader& header() { return m_header; }


     RTPS_DllAPI inline void body(

             const CompleteAliasBody& _body) { m_body = _body; }

     RTPS_DllAPI inline void body(

             CompleteAliasBody&& _body) { m_body = std::move(_body); }

     RTPS_DllAPI inline const CompleteAliasBody& body() const { return m_body; }

     RTPS_DllAPI inline CompleteAliasBody& body() { return m_body; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteAliasType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteAliasType& other) const;


     //    RTPS_DllAPI bool consistent(const CompleteAliasType &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AliasTypeFlag m_alias_flags;

     CompleteAliasHeader m_header;

     CompleteAliasBody m_body;

 };

 /*struct MinimalAliasType final{

     AliasTypeFlag         alias_flags;

     MinimalAliasHeader    header;

     MinimalAliasBody      body;

    };*/

 class MinimalAliasType

 {

 public:


     RTPS_DllAPI MinimalAliasType();

     RTPS_DllAPI ~MinimalAliasType();

     RTPS_DllAPI MinimalAliasType(

             const MinimalAliasType& x);

     RTPS_DllAPI MinimalAliasType(

             MinimalAliasType&& x);

     RTPS_DllAPI MinimalAliasType& operator=(

             const MinimalAliasType& x);

     RTPS_DllAPI MinimalAliasType& operator=(

             MinimalAliasType&& x);


     RTPS_DllAPI inline void alias_flags(

             const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }

     RTPS_DllAPI inline void alias_flags(

             AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }

     RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }

     RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }


     RTPS_DllAPI inline void header(

             const MinimalAliasHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalAliasHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalAliasHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalAliasHeader& header() { return m_header; }


     RTPS_DllAPI inline void body(

             const MinimalAliasBody& _body) { m_body = _body; }

     RTPS_DllAPI inline void body(

             MinimalAliasBody&& _body) { m_body = std::move(_body); }

     RTPS_DllAPI inline const MinimalAliasBody& body() const { return m_body; }

     RTPS_DllAPI inline MinimalAliasBody& body() { return m_body; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalAliasType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalAliasType& other) const;


     //    RTPS_DllAPI bool consistent(const MinimalAliasType &x,

     //        const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AliasTypeFlag m_alias_flags;

     MinimalAliasHeader m_header;

     MinimalAliasBody m_body;

 };


 // --- Collections: ---------------------------------------------------

 /*struct CompleteElementDetail final{

     AppliedBuiltinMemberAnnotations  ann_builtin; // Optional

     AppliedAnnotationSeq             ann_custom; // Optional

    };*/

 class CompleteElementDetail

 {

 public:


     RTPS_DllAPI CompleteElementDetail();

     RTPS_DllAPI ~CompleteElementDetail();

     RTPS_DllAPI CompleteElementDetail(

             const CompleteElementDetail& x);

     RTPS_DllAPI CompleteElementDetail(

             CompleteElementDetail&& x);

     RTPS_DllAPI CompleteElementDetail& operator=(

             const CompleteElementDetail& x);

     RTPS_DllAPI CompleteElementDetail& operator=(

             CompleteElementDetail&& x);


     RTPS_DllAPI inline void ann_builtin(

             const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }

     RTPS_DllAPI inline void ann_builtin(

             AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }

     RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }

     RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }


     RTPS_DllAPI inline void ann_custom(

             const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }

     RTPS_DllAPI inline void ann_custom(

             AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }

     RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }

     RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteElementDetail& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteElementDetail& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteElementDetail& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     AppliedBuiltinMemberAnnotations m_ann_builtin;

     AppliedAnnotationSeq m_ann_custom;

 };

 /*struct CommonCollectionElement final{

     CollectionElementFlag     element_flags;

     TypeIdentifier            type;

    };*/

 class CommonCollectionElement final

 {

 public:


     RTPS_DllAPI CommonCollectionElement();

     RTPS_DllAPI ~CommonCollectionElement();

     RTPS_DllAPI CommonCollectionElement(

             const CommonCollectionElement& x);

     RTPS_DllAPI CommonCollectionElement(

             CommonCollectionElement&& x);

     RTPS_DllAPI CommonCollectionElement& operator=(

             const CommonCollectionElement& x);

     RTPS_DllAPI CommonCollectionElement& operator=(

             CommonCollectionElement&& x);


     RTPS_DllAPI inline void element_flags(

             const CollectionElementFlag& _element_flags) { m_element_flags = _element_flags; }

     RTPS_DllAPI inline void element_flags(

             CollectionElementFlag&& _element_flags) { m_element_flags = std::move(_element_flags); }

     RTPS_DllAPI inline const CollectionElementFlag& element_flags() const { return m_element_flags; }

     RTPS_DllAPI inline CollectionElementFlag& element_flags() { return m_element_flags; }


     RTPS_DllAPI inline void type(

             const TypeIdentifier& _type) { m_type = _type; }

     RTPS_DllAPI inline void type(

             TypeIdentifier&& _type) { m_type = std::move(_type); }

     RTPS_DllAPI inline const TypeIdentifier& type() const { return m_type; }

     RTPS_DllAPI inline TypeIdentifier& type() { return m_type; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonCollectionElement& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonCollectionElement& other) const;


     RTPS_DllAPI bool consistent(

             const CommonCollectionElement& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionElementFlag m_element_flags;

     TypeIdentifier m_type;

 };


 /*struct CompleteCollectionElement {

     CommonCollectionElement   common;

     CompleteElementDetail     detail;

    };*/

 class CompleteCollectionElement

 {

 public:


     RTPS_DllAPI CompleteCollectionElement();

     RTPS_DllAPI ~CompleteCollectionElement();

     RTPS_DllAPI CompleteCollectionElement(

             const CompleteCollectionElement& x);

     RTPS_DllAPI CompleteCollectionElement(

             CompleteCollectionElement&& x);

     RTPS_DllAPI CompleteCollectionElement& operator=(

             const CompleteCollectionElement& x);

     RTPS_DllAPI CompleteCollectionElement& operator=(

             CompleteCollectionElement&& x);


     RTPS_DllAPI inline void common(

             const CommonCollectionElement& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonCollectionElement&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }

     RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteElementDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteElementDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteElementDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteElementDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteCollectionElement& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteCollectionElement& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteCollectionElement& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonCollectionElement m_common;

     CompleteElementDetail m_detail;

 };


 /*struct MinimalCollectionElement {

     CommonCollectionElement   common;

    };*/

 class MinimalCollectionElement

 {

 public:


     RTPS_DllAPI MinimalCollectionElement();

     RTPS_DllAPI ~MinimalCollectionElement();

     RTPS_DllAPI MinimalCollectionElement(

             const MinimalCollectionElement& x);

     RTPS_DllAPI MinimalCollectionElement(

             MinimalCollectionElement&& x);

     RTPS_DllAPI MinimalCollectionElement& operator=(

             const MinimalCollectionElement& x);

     RTPS_DllAPI MinimalCollectionElement& operator=(

             MinimalCollectionElement&& x);


     RTPS_DllAPI inline void common(

             const CommonCollectionElement& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonCollectionElement&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }

     RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalCollectionElement& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalCollectionElement& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalCollectionElement& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonCollectionElement m_common;

 };


 /*struct CommonCollectionHeader final{

     LBound                    bound;

    };*/

 class CommonCollectionHeader

 {

 public:


     RTPS_DllAPI CommonCollectionHeader();

     RTPS_DllAPI ~CommonCollectionHeader();

     RTPS_DllAPI CommonCollectionHeader(

             const CommonCollectionHeader& x);

     RTPS_DllAPI CommonCollectionHeader(

             CommonCollectionHeader&& x);

     RTPS_DllAPI CommonCollectionHeader& operator=(

             const CommonCollectionHeader& x);

     RTPS_DllAPI CommonCollectionHeader& operator=(

             CommonCollectionHeader&& x);


     RTPS_DllAPI inline void bound(

             const LBound& _bound) { m_bound = _bound; }

     RTPS_DllAPI inline void bound(

             LBound&& _bound) { m_bound = std::move(_bound); }

     RTPS_DllAPI inline const LBound& bound() const { return m_bound; }

     RTPS_DllAPI inline LBound& bound() { return m_bound; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonCollectionHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonCollectionHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CommonCollectionHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     LBound m_bound;

 };


 /*struct CompleteCollectionHeader {

     CommonCollectionHeader        common;

     CompleteTypeDetail  detail; // Optional // not present for anonymous

    };*/

 class CompleteCollectionHeader

 {

 public:


     RTPS_DllAPI CompleteCollectionHeader();

     RTPS_DllAPI ~CompleteCollectionHeader();

     RTPS_DllAPI CompleteCollectionHeader(

             const CompleteCollectionHeader& x);

     RTPS_DllAPI CompleteCollectionHeader(

             CompleteCollectionHeader&& x);

     RTPS_DllAPI CompleteCollectionHeader& operator=(

             const CompleteCollectionHeader& x);

     RTPS_DllAPI CompleteCollectionHeader& operator=(

             CompleteCollectionHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonCollectionHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonCollectionHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteCollectionHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteCollectionHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteCollectionHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonCollectionHeader m_common;

     CompleteTypeDetail m_detail;

 };


 /*struct MinimalCollectionHeader {

     CommonCollectionHeader        common;

    };*/

 class MinimalCollectionHeader

 {

 public:


     RTPS_DllAPI MinimalCollectionHeader();

     RTPS_DllAPI ~MinimalCollectionHeader();

     RTPS_DllAPI MinimalCollectionHeader(

             const MinimalCollectionHeader& x);

     RTPS_DllAPI MinimalCollectionHeader(

             MinimalCollectionHeader&& x);

     RTPS_DllAPI MinimalCollectionHeader& operator=(

             const MinimalCollectionHeader& x);

     RTPS_DllAPI MinimalCollectionHeader& operator=(

             MinimalCollectionHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonCollectionHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonCollectionHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalCollectionHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalCollectionHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalCollectionHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonCollectionHeader m_common;

 };


 // --- Sequence: -----------------------------------------------------

 /*struct CompleteSequenceType final{

     CollectionTypeFlag         collection_flag;

     CompleteCollectionHeader   header;

     CompleteCollectionElement  element;

    };*/

 class CompleteSequenceType

 {

 public:


     RTPS_DllAPI CompleteSequenceType();

     RTPS_DllAPI ~CompleteSequenceType();

     RTPS_DllAPI CompleteSequenceType(

             const CompleteSequenceType& x);

     RTPS_DllAPI CompleteSequenceType(

             CompleteSequenceType&& x);

     RTPS_DllAPI CompleteSequenceType& operator=(

             const CompleteSequenceType& x);

     RTPS_DllAPI CompleteSequenceType& operator=(

             CompleteSequenceType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const CompleteCollectionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteCollectionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }


     RTPS_DllAPI inline void element(

             const CompleteCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             CompleteCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteSequenceType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteSequenceType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteSequenceType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     CompleteCollectionHeader m_header;

     CompleteCollectionElement m_element;

 };


 /*struct MinimalSequenceType final{

     CollectionTypeFlag         collection_flag;

     MinimalCollectionHeader    header;

     MinimalCollectionElement   element;

    };*/

 class MinimalSequenceType

 {

 public:


     RTPS_DllAPI MinimalSequenceType();

     RTPS_DllAPI ~MinimalSequenceType();

     RTPS_DllAPI MinimalSequenceType(

             const MinimalSequenceType& x);

     RTPS_DllAPI MinimalSequenceType(

             MinimalSequenceType&& x);

     RTPS_DllAPI MinimalSequenceType& operator=(

             const MinimalSequenceType& x);

     RTPS_DllAPI MinimalSequenceType& operator=(

             MinimalSequenceType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const MinimalCollectionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalCollectionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }


     RTPS_DllAPI inline void element(

             const MinimalCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             MinimalCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalSequenceType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalSequenceType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalSequenceType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     MinimalCollectionHeader m_header;

     MinimalCollectionElement m_element;

 };


 // --- Array: -----------------------------------------------------

 /*struct CommonArrayHeader final{

     LBoundSeq           bound_seq;

    };*/

 class CommonArrayHeader

 {

 public:


     RTPS_DllAPI CommonArrayHeader();

     RTPS_DllAPI ~CommonArrayHeader();

     RTPS_DllAPI CommonArrayHeader(

             const CommonArrayHeader& x);

     RTPS_DllAPI CommonArrayHeader(

             CommonArrayHeader&& x);

     RTPS_DllAPI CommonArrayHeader& operator=(

             const CommonArrayHeader& x);

     RTPS_DllAPI CommonArrayHeader& operator=(

             CommonArrayHeader&& x);


     RTPS_DllAPI inline void bound_seq(

             const LBoundSeq& _bound_seq) { m_bound_seq = _bound_seq; }

     RTPS_DllAPI inline void bound_seq(

             LBoundSeq&& _bound_seq) { m_bound_seq = std::move(_bound_seq); }

     RTPS_DllAPI inline const LBoundSeq& bound_seq() const { return m_bound_seq; }

     RTPS_DllAPI inline LBoundSeq& bound_seq() { return m_bound_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonArrayHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonArrayHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CommonArrayHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     LBoundSeq m_bound_seq;

 };


 /*struct CompleteArrayHeader {

     CommonArrayHeader   common;

     CompleteTypeDetail  detail;

    };*/

 class CompleteArrayHeader

 {

 public:


     RTPS_DllAPI CompleteArrayHeader();

     RTPS_DllAPI ~CompleteArrayHeader();

     RTPS_DllAPI CompleteArrayHeader(

             const CompleteArrayHeader& x);

     RTPS_DllAPI CompleteArrayHeader(

             CompleteArrayHeader&& x);

     RTPS_DllAPI CompleteArrayHeader& operator=(

             const CompleteArrayHeader& x);

     RTPS_DllAPI CompleteArrayHeader& operator=(

             CompleteArrayHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonArrayHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonArrayHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteArrayHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteArrayHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteArrayHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonArrayHeader m_common;

     CompleteTypeDetail m_detail;

 };


 /*struct MinimalArrayHeader {

     CommonArrayHeader   common;

    };*/

 class MinimalArrayHeader

 {

 public:


     RTPS_DllAPI MinimalArrayHeader();

     RTPS_DllAPI ~MinimalArrayHeader();

     RTPS_DllAPI MinimalArrayHeader(

             const MinimalArrayHeader& x);

     RTPS_DllAPI MinimalArrayHeader(

             MinimalArrayHeader&& x);

     RTPS_DllAPI MinimalArrayHeader& operator=(

             const MinimalArrayHeader& x);

     RTPS_DllAPI MinimalArrayHeader& operator=(

             MinimalArrayHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonArrayHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonArrayHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalArrayHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalArrayHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalArrayHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonArrayHeader m_common;

 };


 /*struct CompleteArrayType  {

     CollectionTypeFlag          collection_flag;

     CompleteArrayHeader         header;

     CompleteCollectionElement   element;

    };*/

 class CompleteArrayType

 {

 public:


     RTPS_DllAPI CompleteArrayType();

     RTPS_DllAPI ~CompleteArrayType();

     RTPS_DllAPI CompleteArrayType(

             const CompleteArrayType& x);

     RTPS_DllAPI CompleteArrayType(

             CompleteArrayType&& x);

     RTPS_DllAPI CompleteArrayType& operator=(

             const CompleteArrayType& x);

     RTPS_DllAPI CompleteArrayType& operator=(

             CompleteArrayType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const CompleteArrayHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteArrayHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteArrayHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteArrayHeader& header() { return m_header; }


     RTPS_DllAPI inline void element(

             const CompleteCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             CompleteCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteArrayType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteArrayType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteArrayType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     CompleteArrayHeader m_header;

     CompleteCollectionElement m_element;

 };


 /*struct MinimalArrayType final{

     CollectionTypeFlag         collection_flag;

     MinimalArrayHeader         header;

     MinimalCollectionElement   element;

    };*/

 class MinimalArrayType

 {

 public:


     RTPS_DllAPI MinimalArrayType();

     RTPS_DllAPI ~MinimalArrayType();

     RTPS_DllAPI MinimalArrayType(

             const MinimalArrayType& x);

     RTPS_DllAPI MinimalArrayType(

             MinimalArrayType&& x);

     RTPS_DllAPI MinimalArrayType& operator=(

             const MinimalArrayType& x);

     RTPS_DllAPI MinimalArrayType& operator=(

             MinimalArrayType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const MinimalArrayHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalArrayHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalArrayHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalArrayHeader& header() { return m_header; }


     RTPS_DllAPI inline void element(

             const MinimalCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             MinimalCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalArrayType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalArrayType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalArrayType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     MinimalArrayHeader m_header;

     MinimalCollectionElement m_element;

 };


 // --- Map: -----------------------------------------------------

 /*struct CompleteMapType final{

     CollectionTypeFlag            collection_flag;

     CompleteCollectionHeader      header;

     CompleteCollectionElement     key;

     CompleteCollectionElement     element;

    };*/

 class CompleteMapType final

 {

 public:


     RTPS_DllAPI CompleteMapType();

     RTPS_DllAPI ~CompleteMapType();

     RTPS_DllAPI CompleteMapType(

             const CompleteMapType& x);

     RTPS_DllAPI CompleteMapType(

             CompleteMapType&& x);

     RTPS_DllAPI CompleteMapType& operator=(

             const CompleteMapType& x);

     RTPS_DllAPI CompleteMapType& operator=(

             CompleteMapType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const CompleteCollectionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteCollectionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }


     RTPS_DllAPI inline void key(

             const CompleteCollectionElement& _key) { m_key = _key; }

     RTPS_DllAPI inline void key(

             CompleteCollectionElement&& _key) { m_key = std::move(_key); }

     RTPS_DllAPI inline const CompleteCollectionElement& key() const { return m_key; }

     RTPS_DllAPI inline CompleteCollectionElement& key() { return m_key; }


     RTPS_DllAPI inline void element(

             const CompleteCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             CompleteCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteMapType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteMapType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteMapType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     CompleteCollectionHeader m_header;

     CompleteCollectionElement m_key;

     CompleteCollectionElement m_element;

 };

 /*struct MinimalMapType final{

     CollectionTypeFlag          collection_flag;

     MinimalCollectionHeader     header;

     MinimalCollectionElement    key;

     MinimalCollectionElement    element;

    };*/

 class MinimalMapType final

 {

 public:


     RTPS_DllAPI MinimalMapType();

     RTPS_DllAPI ~MinimalMapType();

     RTPS_DllAPI MinimalMapType(

             const MinimalMapType& x);

     RTPS_DllAPI MinimalMapType(

             MinimalMapType&& x);

     RTPS_DllAPI MinimalMapType& operator=(

             const MinimalMapType& x);

     RTPS_DllAPI MinimalMapType& operator=(

             MinimalMapType&& x);


     RTPS_DllAPI inline void collection_flag(

             const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }

     RTPS_DllAPI inline void collection_flag(

             CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }

     RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }

     RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }


     RTPS_DllAPI inline void header(

             const MinimalCollectionHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalCollectionHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }


     RTPS_DllAPI inline void key(

             const MinimalCollectionElement& _key) { m_key = _key; }

     RTPS_DllAPI inline void key(

             MinimalCollectionElement&& _key) { m_key = std::move(_key); }

     RTPS_DllAPI inline const MinimalCollectionElement& key() const { return m_key; }

     RTPS_DllAPI inline MinimalCollectionElement& key() { return m_key; }


     RTPS_DllAPI inline void element(

             const MinimalCollectionElement& _element) { m_element = _element; }

     RTPS_DllAPI inline void element(

             MinimalCollectionElement&& _element) { m_element = std::move(_element); }

     RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }

     RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalMapType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalMapType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalMapType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CollectionTypeFlag m_collection_flag;

     MinimalCollectionHeader m_header;

     MinimalCollectionElement m_key;

     MinimalCollectionElement m_element;

 };


 // --- Enumeration: ---------------------------------------------------

 typedef uint16_t BitBound;


 // Constant in an enumerated type


 /*struct CommonEnumeratedLiteral {

     int32_t                     value;

     EnumeratedLiteralFlag    flags;

    };*/

 class CommonEnumeratedLiteral

 {

 public:


     RTPS_DllAPI CommonEnumeratedLiteral();

     RTPS_DllAPI ~CommonEnumeratedLiteral();

     RTPS_DllAPI CommonEnumeratedLiteral(

             const CommonEnumeratedLiteral& x);

     RTPS_DllAPI CommonEnumeratedLiteral(

             CommonEnumeratedLiteral&& x);

     RTPS_DllAPI CommonEnumeratedLiteral& operator=(

             const CommonEnumeratedLiteral& x);

     RTPS_DllAPI CommonEnumeratedLiteral& operator=(

             CommonEnumeratedLiteral&& x);


     RTPS_DllAPI inline void value(

             const int32_t& _value) { m_value = _value; }

     RTPS_DllAPI inline void value(

             int32_t&& _value) { m_value = std::move(_value); }

     RTPS_DllAPI inline const int32_t& value() const { return m_value; }

     RTPS_DllAPI inline int32_t& value() { return m_value; }


     RTPS_DllAPI inline void flags(

             const EnumeratedLiteralFlag& _flags) { m_flags = _flags; }

     RTPS_DllAPI inline void flags(

             EnumeratedLiteralFlag&& _flags) { m_flags = std::move(_flags); }

     RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const { return m_flags; }

     RTPS_DllAPI inline EnumeratedLiteralFlag& flags() { return m_flags; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonEnumeratedLiteral& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonEnumeratedLiteral& other) const;


     RTPS_DllAPI bool consistent(

             const CommonEnumeratedLiteral& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     int32_t m_value;

     EnumeratedLiteralFlag m_flags;

 };


 // Constant in an enumerated type


 /*struct CompleteEnumeratedLiteral {

     CommonEnumeratedLiteral  common;

     CompleteMemberDetail     detail;

    };*/

 class CompleteEnumeratedLiteral

 {

 public:


     RTPS_DllAPI CompleteEnumeratedLiteral();

     RTPS_DllAPI ~CompleteEnumeratedLiteral();

     RTPS_DllAPI CompleteEnumeratedLiteral(

             const CompleteEnumeratedLiteral& x);

     RTPS_DllAPI CompleteEnumeratedLiteral(

             CompleteEnumeratedLiteral&& x);

     RTPS_DllAPI CompleteEnumeratedLiteral& operator=(

             const CompleteEnumeratedLiteral& x);

     RTPS_DllAPI CompleteEnumeratedLiteral& operator=(

             CompleteEnumeratedLiteral&& x);


     RTPS_DllAPI inline void common(

             const CommonEnumeratedLiteral& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }

     RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteEnumeratedLiteral& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteEnumeratedLiteral& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteEnumeratedLiteral& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonEnumeratedLiteral m_common;

     CompleteMemberDetail m_detail;

 };

 // Ordered by EnumeratedLiteral.common.value

 typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;


 // Constant in an enumerated type


 /*struct MinimalEnumeratedLiteral {

     CommonEnumeratedLiteral  common;

     MinimalMemberDetail      detail;

    };*/

 class MinimalEnumeratedLiteral

 {

 public:


     RTPS_DllAPI MinimalEnumeratedLiteral();

     RTPS_DllAPI ~MinimalEnumeratedLiteral();

     RTPS_DllAPI MinimalEnumeratedLiteral(

             const MinimalEnumeratedLiteral& x);

     RTPS_DllAPI MinimalEnumeratedLiteral(

             MinimalEnumeratedLiteral&& x);

     RTPS_DllAPI MinimalEnumeratedLiteral& operator=(

             const MinimalEnumeratedLiteral& x);

     RTPS_DllAPI MinimalEnumeratedLiteral& operator=(

             MinimalEnumeratedLiteral&& x);


     RTPS_DllAPI inline void common(

             const CommonEnumeratedLiteral& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }

     RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const MinimalMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalEnumeratedLiteral& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalEnumeratedLiteral& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalEnumeratedLiteral& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonEnumeratedLiteral m_common;

     MinimalMemberDetail m_detail;

 };


 // Ordered by EnumeratedLiteral.common.value

 typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;


 /*struct CommonEnumeratedHeader final{

     BitBound                bit_bound;

    };*/

 class CommonEnumeratedHeader final

 {

 public:


     RTPS_DllAPI CommonEnumeratedHeader();

     RTPS_DllAPI ~CommonEnumeratedHeader();

     RTPS_DllAPI CommonEnumeratedHeader(

             const CommonEnumeratedHeader& x);

     RTPS_DllAPI CommonEnumeratedHeader(

             CommonEnumeratedHeader&& x);

     RTPS_DllAPI CommonEnumeratedHeader& operator=(

             const CommonEnumeratedHeader& x);

     RTPS_DllAPI CommonEnumeratedHeader& operator=(

             CommonEnumeratedHeader&& x);


     RTPS_DllAPI inline void bit_bound(

             const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }

     RTPS_DllAPI inline void bit_bound(

             BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }

     RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }

     RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonEnumeratedHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonEnumeratedHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CommonEnumeratedHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitBound m_bit_bound;

 };


 /*struct CompleteEnumeratedHeader {

     CommonEnumeratedHeader  common;

     CompleteTypeDetail      detail;

    };*/

 class CompleteEnumeratedHeader

 {

 public:


     RTPS_DllAPI CompleteEnumeratedHeader();

     RTPS_DllAPI ~CompleteEnumeratedHeader();

     RTPS_DllAPI CompleteEnumeratedHeader(

             const CompleteEnumeratedHeader& x);

     RTPS_DllAPI CompleteEnumeratedHeader(

             CompleteEnumeratedHeader&& x);

     RTPS_DllAPI CompleteEnumeratedHeader& operator=(

             const CompleteEnumeratedHeader& x);

     RTPS_DllAPI CompleteEnumeratedHeader& operator=(

             CompleteEnumeratedHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonEnumeratedHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteEnumeratedHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteEnumeratedHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteEnumeratedHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonEnumeratedHeader m_common;

     CompleteTypeDetail m_detail;

 };


 /*struct MinimalEnumeratedHeader {

     CommonEnumeratedHeader  common;

    };*/

 class MinimalEnumeratedHeader

 {

 public:


     RTPS_DllAPI MinimalEnumeratedHeader();

     RTPS_DllAPI ~MinimalEnumeratedHeader();

     RTPS_DllAPI MinimalEnumeratedHeader(

             const MinimalEnumeratedHeader& x);

     RTPS_DllAPI MinimalEnumeratedHeader(

             MinimalEnumeratedHeader&& x);

     RTPS_DllAPI MinimalEnumeratedHeader& operator=(

             const MinimalEnumeratedHeader& x);

     RTPS_DllAPI MinimalEnumeratedHeader& operator=(

             MinimalEnumeratedHeader&& x);


     RTPS_DllAPI inline void common(

             const CommonEnumeratedHeader& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }

     RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalEnumeratedHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalEnumeratedHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalEnumeratedHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonEnumeratedHeader m_common;

 };


 // Enumerated type

 /*struct CompleteEnumeratedType final{

     EnumTypeFlag                    enum_flags; // unused

     CompleteEnumeratedHeader        header;

     CompleteEnumeratedLiteralSeq    literal_seq;

    };*/

 class CompleteEnumeratedType

 {

 public:


     RTPS_DllAPI CompleteEnumeratedType();

     RTPS_DllAPI ~CompleteEnumeratedType();

     RTPS_DllAPI CompleteEnumeratedType(

             const CompleteEnumeratedType& x);

     RTPS_DllAPI CompleteEnumeratedType(

             CompleteEnumeratedType&& x);

     RTPS_DllAPI CompleteEnumeratedType& operator=(

             const CompleteEnumeratedType& x);

     RTPS_DllAPI CompleteEnumeratedType& operator=(

             CompleteEnumeratedType&& x);


     RTPS_DllAPI inline void enum_flags(

             const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }

     RTPS_DllAPI inline void enum_flags(

             EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }

     RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }

     RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }


     RTPS_DllAPI inline void header(

             const CompleteEnumeratedHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteEnumeratedHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteEnumeratedHeader& header() { return m_header; }


     RTPS_DllAPI inline void literal_seq(

             const CompleteEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }

     RTPS_DllAPI inline void literal_seq(

             CompleteEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }

     RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }

     RTPS_DllAPI inline CompleteEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteEnumeratedType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteEnumeratedType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteEnumeratedType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     EnumTypeFlag m_enum_flags;

     CompleteEnumeratedHeader m_header;

     CompleteEnumeratedLiteralSeq m_literal_seq;

 };

 // Enumerated type

 /*struct MinimalEnumeratedType final{

     EnumTypeFlag                  enum_flags; // unused

     MinimalEnumeratedHeader       header;

     MinimalEnumeratedLiteralSeq   literal_seq;

    };*/

 class MinimalEnumeratedType

 {

 public:


     RTPS_DllAPI MinimalEnumeratedType();

     RTPS_DllAPI ~MinimalEnumeratedType();

     RTPS_DllAPI MinimalEnumeratedType(

             const MinimalEnumeratedType& x);

     RTPS_DllAPI MinimalEnumeratedType(

             MinimalEnumeratedType&& x);

     RTPS_DllAPI MinimalEnumeratedType& operator=(

             const MinimalEnumeratedType& x);

     RTPS_DllAPI MinimalEnumeratedType& operator=(

             MinimalEnumeratedType&& x);


     RTPS_DllAPI inline void enum_flags(

             const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }

     RTPS_DllAPI inline void enum_flags(

             EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }

     RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }

     RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }


     RTPS_DllAPI inline void header(

             const MinimalEnumeratedHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalEnumeratedHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalEnumeratedHeader& header() { return m_header; }


     RTPS_DllAPI inline void literal_seq(

             const MinimalEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }

     RTPS_DllAPI inline void literal_seq(

             MinimalEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }

     RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }

     RTPS_DllAPI inline MinimalEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalEnumeratedType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalEnumeratedType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalEnumeratedType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     EnumTypeFlag m_enum_flags;

     MinimalEnumeratedHeader m_header;

     MinimalEnumeratedLiteralSeq m_literal_seq;

 };


 // --- Bitmask: -------------------------------------------------------

 // Bit in a bit mask

 /*struct CommonBitflag final{

     uint16_t         position;

     BitflagFlag            flags;

    };*/

 class CommonBitflag final

 {

 public:


     RTPS_DllAPI CommonBitflag();

     RTPS_DllAPI ~CommonBitflag();

     RTPS_DllAPI CommonBitflag(

             const CommonBitflag& x);

     RTPS_DllAPI CommonBitflag(

             CommonBitflag&& x);

     RTPS_DllAPI CommonBitflag& operator=(

             const CommonBitflag& x);

     RTPS_DllAPI CommonBitflag& operator=(

             CommonBitflag&& x);


     RTPS_DllAPI inline void position(

             const uint16_t& _position) { m_position = _position; }

     RTPS_DllAPI inline void position(

             uint16_t&& _position) { m_position = std::move(_position); }

     RTPS_DllAPI inline const uint16_t& position() const { return m_position; }

     RTPS_DllAPI inline uint16_t& position() { return m_position; }


     RTPS_DllAPI inline void flags(

             const BitflagFlag& _flags) { m_flags = _flags; }

     RTPS_DllAPI inline void flags(

             BitflagFlag&& _flags) { m_flags = std::move(_flags); }

     RTPS_DllAPI inline const BitflagFlag& flags() const { return m_flags; }

     RTPS_DllAPI inline BitflagFlag& flags() { return m_flags; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonBitflag& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonBitflag& other) const;


     RTPS_DllAPI bool consistent(

             const CommonBitflag& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     uint16_t m_position;

     BitflagFlag m_flags;

 };


 /*struct CompleteBitflag {

     CommonBitflag          common;

     CompleteMemberDetail   detail;

    };*/

 class CompleteBitflag

 {

 public:


     RTPS_DllAPI CompleteBitflag();

     RTPS_DllAPI ~CompleteBitflag();

     RTPS_DllAPI CompleteBitflag(

             const CompleteBitflag& x);

     RTPS_DllAPI CompleteBitflag(

             CompleteBitflag&& x);

     RTPS_DllAPI CompleteBitflag& operator=(

             const CompleteBitflag& x);

     RTPS_DllAPI CompleteBitflag& operator=(

             CompleteBitflag&& x);


     RTPS_DllAPI inline void common(

             const CommonBitflag& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonBitflag&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }

     RTPS_DllAPI inline CommonBitflag& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteBitflag& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteBitflag& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteBitflag& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonBitflag m_common;

     CompleteMemberDetail m_detail;

 };

 // Ordered by Bitflag.position

 typedef std::vector<CompleteBitflag> CompleteBitflagSeq;

 /*struct MinimalBitflag {

     CommonBitflag        common;

     MinimalMemberDetail  detail;

    };*/

 class MinimalBitflag

 {

 public:


     RTPS_DllAPI MinimalBitflag();

     RTPS_DllAPI ~MinimalBitflag();

     RTPS_DllAPI MinimalBitflag(

             const MinimalBitflag& x);

     RTPS_DllAPI MinimalBitflag(

             MinimalBitflag&& x);

     RTPS_DllAPI MinimalBitflag& operator=(

             const MinimalBitflag& x);

     RTPS_DllAPI MinimalBitflag& operator=(

             MinimalBitflag&& x);


     RTPS_DllAPI inline void common(

             const CommonBitflag& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonBitflag&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }

     RTPS_DllAPI inline CommonBitflag& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const MinimalMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalBitflag& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalBitflag& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalBitflag& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonBitflag m_common;

     MinimalMemberDetail m_detail;

 };


 // Ordered by Bitflag.position

 typedef std::vector<MinimalBitflag> MinimalBitflagSeq;


 /*struct CommonBitmaskHeader final{

     BitBound             bit_bound;

    };*/

 class CommonBitmaskHeader final

 {

 public:


     RTPS_DllAPI CommonBitmaskHeader();

     RTPS_DllAPI ~CommonBitmaskHeader();

     RTPS_DllAPI CommonBitmaskHeader(

             const CommonBitmaskHeader& x);

     RTPS_DllAPI CommonBitmaskHeader(

             CommonBitmaskHeader&& x);

     RTPS_DllAPI CommonBitmaskHeader& operator=(

             const CommonBitmaskHeader& x);

     RTPS_DllAPI CommonBitmaskHeader& operator=(

             CommonBitmaskHeader&& x);


     RTPS_DllAPI inline void bit_bound(

             const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }

     RTPS_DllAPI inline void bit_bound(

             BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }

     RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }

     RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonBitmaskHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonBitmaskHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CommonBitmaskHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitBound m_bit_bound;

 };

 typedef CompleteEnumeratedHeader CompleteBitmaskHeader;


 typedef MinimalEnumeratedHeader MinimalBitmaskHeader;

 /*struct CompleteBitmaskType {

     BitmaskTypeFlag          bitmask_flags; // unused

     CompleteBitmaskHeader    header;

     CompleteBitflagSeq       flag_seq;

    };*/

 class CompleteBitmaskType

 {

 public:


     RTPS_DllAPI CompleteBitmaskType();

     RTPS_DllAPI ~CompleteBitmaskType();

     RTPS_DllAPI CompleteBitmaskType(

             const CompleteBitmaskType& x);

     RTPS_DllAPI CompleteBitmaskType(

             CompleteBitmaskType&& x);

     RTPS_DllAPI CompleteBitmaskType& operator=(

             const CompleteBitmaskType& x);

     RTPS_DllAPI CompleteBitmaskType& operator=(

             CompleteBitmaskType&& x);


     RTPS_DllAPI inline void bitmask_flags(

             const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }

     RTPS_DllAPI inline void bitmask_flags(

             BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }

     RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }

     RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }


     RTPS_DllAPI inline void header(

             const CompleteBitmaskHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteBitmaskHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteBitmaskHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteBitmaskHeader& header() { return m_header; }


     RTPS_DllAPI inline void flag_seq(

             const CompleteBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }

     RTPS_DllAPI inline void flag_seq(

             CompleteBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }

     RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const { return m_flag_seq; }

     RTPS_DllAPI inline CompleteBitflagSeq& flag_seq() { return m_flag_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteBitmaskType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteBitmaskType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteBitmaskType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitmaskTypeFlag m_bitmask_flags;

     CompleteBitmaskHeader m_header;

     CompleteBitflagSeq m_flag_seq;

 };


 /*struct MinimalBitmaskType {

     BitmaskTypeFlag          bitmask_flags; // unused

     MinimalBitmaskHeader     header;

     MinimalBitflagSeq        flag_seq;

    };*/

 class MinimalBitmaskType

 {

 public:


     RTPS_DllAPI MinimalBitmaskType();

     RTPS_DllAPI ~MinimalBitmaskType();

     RTPS_DllAPI MinimalBitmaskType(

             const MinimalBitmaskType& x);

     RTPS_DllAPI MinimalBitmaskType(

             MinimalBitmaskType&& x);

     RTPS_DllAPI MinimalBitmaskType& operator=(

             const MinimalBitmaskType& x);

     RTPS_DllAPI MinimalBitmaskType& operator=(

             MinimalBitmaskType&& x);


     RTPS_DllAPI inline void bitmask_flags(

             const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }

     RTPS_DllAPI inline void bitmask_flags(

             BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }

     RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }

     RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }


     RTPS_DllAPI inline void header(

             const MinimalBitmaskHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalBitmaskHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalBitmaskHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalBitmaskHeader& header() { return m_header; }


     RTPS_DllAPI inline void flag_seq(

             const MinimalBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }

     RTPS_DllAPI inline void flag_seq(

             MinimalBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }

     RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const { return m_flag_seq; }

     RTPS_DllAPI inline MinimalBitflagSeq& flag_seq() { return m_flag_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalBitmaskType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalBitmaskType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalBitmaskType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitmaskTypeFlag m_bitmask_flags;

     MinimalBitmaskHeader m_header;

     MinimalBitflagSeq m_flag_seq;

 };


 // --- Bitset: ---------------------------------------------------------

 /*struct CommonBitfield final{

     uint16_t        position;

     BitsetMemberFlag      flags;

     octet                 bitcount;

     TypeKind              holder_type; // Must be primitive integer type

    };*/

 class CommonBitfield final

 {

 public:


     RTPS_DllAPI CommonBitfield();

     RTPS_DllAPI ~CommonBitfield();

     RTPS_DllAPI CommonBitfield(

             const CommonBitfield& x);

     RTPS_DllAPI CommonBitfield(

             CommonBitfield&& x);

     RTPS_DllAPI CommonBitfield& operator=(

             const CommonBitfield& x);

     RTPS_DllAPI CommonBitfield& operator=(

             CommonBitfield&& x);


     RTPS_DllAPI inline void position(

             const uint16_t& _position) { m_position = _position; }

     RTPS_DllAPI inline void position(

             uint16_t&& _position) { m_position = std::move(_position); }

     RTPS_DllAPI inline const uint16_t& position() const { return m_position; }

     RTPS_DllAPI inline uint16_t& position() { return m_position; }


     RTPS_DllAPI inline void flags(

             const BitsetMemberFlag& _flags) { m_flags = _flags; }

     RTPS_DllAPI inline void flags(

             BitsetMemberFlag&& _flags) { m_flags = std::move(_flags); }

     RTPS_DllAPI inline const BitsetMemberFlag& flags() const { return m_flags; }

     RTPS_DllAPI inline BitsetMemberFlag& flags() { return m_flags; }


     RTPS_DllAPI inline void bitcount(

             const octet& _bitcount) { m_bitcount = _bitcount; }

     RTPS_DllAPI inline void bitcount(

             octet&& _bitcount) { m_bitcount = std::move(_bitcount); }

     RTPS_DllAPI inline const octet& bitcount() const { return m_bitcount; }

     RTPS_DllAPI inline octet& bitcount() { return m_bitcount; }


     RTPS_DllAPI inline void holder_type(

             const TypeKind& _holder_type) { m_holder_type = _holder_type; }

     RTPS_DllAPI inline void holder_type(

             TypeKind&& _holder_type) { m_holder_type = std::move(_holder_type); }

     RTPS_DllAPI inline const TypeKind& holder_type() const { return m_holder_type; }

     RTPS_DllAPI inline TypeKind& holder_type() { return m_holder_type; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CommonBitfield& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CommonBitfield& other) const;


     RTPS_DllAPI bool consistent(

             const CommonBitfield& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     uint16_t m_position;

     BitsetMemberFlag m_flags;

     octet m_bitcount;

     TypeKind m_holder_type;

 };


 /*struct CompleteBitfield {

     CommonBitfield           common;

     CompleteMemberDetail     detail;

    };*/

 class CompleteBitfield

 {

 public:


     RTPS_DllAPI CompleteBitfield();

     RTPS_DllAPI ~CompleteBitfield();

     RTPS_DllAPI CompleteBitfield(

             const CompleteBitfield& x);

     RTPS_DllAPI CompleteBitfield(

             CompleteBitfield&& x);

     RTPS_DllAPI CompleteBitfield& operator=(

             const CompleteBitfield& x);

     RTPS_DllAPI CompleteBitfield& operator=(

             CompleteBitfield&& x);


     RTPS_DllAPI inline void common(

             const CommonBitfield& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonBitfield&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }

     RTPS_DllAPI inline CommonBitfield& common() { return m_common; }


     RTPS_DllAPI inline void detail(

             const CompleteMemberDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteBitfield& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteBitfield& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteBitfield& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonBitfield m_common;

     CompleteMemberDetail m_detail;

 };

 // Ordered by Bitfield.position

 typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;

 /*struct MinimalBitfield {

     CommonBitfield       common;

     NameHash             name_hash;

    };*/

 class MinimalBitfield

 {

 public:


     RTPS_DllAPI MinimalBitfield();

     RTPS_DllAPI ~MinimalBitfield();

     RTPS_DllAPI MinimalBitfield(

             const MinimalBitfield& x);

     RTPS_DllAPI MinimalBitfield(

             MinimalBitfield&& x);

     RTPS_DllAPI MinimalBitfield& operator=(

             const MinimalBitfield& x);

     RTPS_DllAPI MinimalBitfield& operator=(

             MinimalBitfield&& x);


     RTPS_DllAPI inline void name_hash(

             const NameHash& _name_hash) { m_name_hash = _name_hash; }

     RTPS_DllAPI inline void name_hash(

             NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }

     RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }

     RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }


     RTPS_DllAPI inline void common(

             const CommonBitfield& _common) { m_common = _common; }

     RTPS_DllAPI inline void common(

             CommonBitfield&& _common) { m_common = std::move(_common); }

     RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }

     RTPS_DllAPI inline CommonBitfield& common() { return m_common; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalBitfield& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalBitfield& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalBitfield& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     CommonBitfield m_common;

     NameHash m_name_hash;

 };

 // Ordered by Bitfield.position

 typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;

 /*struct CompleteBitsetHeader {

     CompleteTypeDetail   detail;

    };*/

 class CompleteBitsetHeader

 {

 public:


     RTPS_DllAPI CompleteBitsetHeader();

     RTPS_DllAPI ~CompleteBitsetHeader();

     RTPS_DllAPI CompleteBitsetHeader(

             const CompleteBitsetHeader& x);

     RTPS_DllAPI CompleteBitsetHeader(

             CompleteBitsetHeader&& x);

     RTPS_DllAPI CompleteBitsetHeader& operator=(

             const CompleteBitsetHeader& x);

     RTPS_DllAPI CompleteBitsetHeader& operator=(

             CompleteBitsetHeader&& x);


     RTPS_DllAPI inline void base_type(

             const TypeIdentifier& _base_type) { m_base_type = _base_type; }

     RTPS_DllAPI inline void base_type(

             TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }

     RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }

     RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }


     RTPS_DllAPI inline void detail(

             const CompleteTypeDetail& _detail) { m_detail = _detail; }

     RTPS_DllAPI inline void detail(

             CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }

     RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }

     RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteBitsetHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteBitsetHeader& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteBitsetHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     TypeIdentifier m_base_type;

     CompleteTypeDetail m_detail;

 };


 /*struct MinimalBitsetHeader {

     // Empty. Available for future extension

    };*/

 class MinimalBitsetHeader

 {

 public:


     RTPS_DllAPI MinimalBitsetHeader();

     RTPS_DllAPI ~MinimalBitsetHeader();

     RTPS_DllAPI MinimalBitsetHeader(

             const MinimalBitsetHeader& x);

     RTPS_DllAPI MinimalBitsetHeader(

             MinimalBitsetHeader&& x);

     RTPS_DllAPI MinimalBitsetHeader& operator=(

             const MinimalBitsetHeader& x);

     RTPS_DllAPI MinimalBitsetHeader& operator=(

             MinimalBitsetHeader&& x);


     RTPS_DllAPI inline void base_type(

             const TypeIdentifier& _base_type) { m_base_type = _base_type; }

     RTPS_DllAPI inline void base_type(

             TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }

     RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }

     RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalBitsetHeader& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalBitsetHeader& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalBitsetHeader& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     TypeIdentifier m_base_type;

 };

 /*struct CompleteBitsetType  {

     BitsetTypeFlag         bitset_flags; // unused

     CompleteBitsetHeader   header;

     CompleteBitfieldSeq    field_seq;

    };*/

 class CompleteBitsetType

 {

 public:


     RTPS_DllAPI CompleteBitsetType();

     RTPS_DllAPI ~CompleteBitsetType();

     RTPS_DllAPI CompleteBitsetType(

             const CompleteBitsetType& x);

     RTPS_DllAPI CompleteBitsetType(

             CompleteBitsetType&& x);

     RTPS_DllAPI CompleteBitsetType& operator=(

             const CompleteBitsetType& x);

     RTPS_DllAPI CompleteBitsetType& operator=(

             CompleteBitsetType&& x);


     RTPS_DllAPI inline void bitset_flags(

             const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }

     RTPS_DllAPI inline void bitset_flags(

             BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }

     RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }

     RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }


     RTPS_DllAPI inline void header(

             const CompleteBitsetHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             CompleteBitsetHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const CompleteBitsetHeader& header() const { return m_header; }

     RTPS_DllAPI inline CompleteBitsetHeader& header() { return m_header; }


     RTPS_DllAPI inline void field_seq(

             const CompleteBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }

     RTPS_DllAPI inline void field_seq(

             CompleteBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }

     RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const { return m_field_seq; }

     RTPS_DllAPI inline CompleteBitfieldSeq& field_seq() { return m_field_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteBitsetType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteBitsetType& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteBitsetType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitsetTypeFlag m_bitset_flags;

     CompleteBitsetHeader m_header;

     CompleteBitfieldSeq m_field_seq;

 };


 /*struct MinimalBitsetType  {

     BitsetTypeFlag       bitset_flags; // unused

     MinimalBitsetHeader  header;

     MinimalBitfieldSeq   field_seq;

    };*/

 class MinimalBitsetType

 {

 public:


     RTPS_DllAPI MinimalBitsetType();

     RTPS_DllAPI ~MinimalBitsetType();

     RTPS_DllAPI MinimalBitsetType(

             const MinimalBitsetType& x);

     RTPS_DllAPI MinimalBitsetType(

             MinimalBitsetType&& x);

     RTPS_DllAPI MinimalBitsetType& operator=(

             const MinimalBitsetType& x);

     RTPS_DllAPI MinimalBitsetType& operator=(

             MinimalBitsetType&& x);


     RTPS_DllAPI inline void bitset_flags(

             const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }

     RTPS_DllAPI inline void bitset_flags(

             BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }

     RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }

     RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }


     RTPS_DllAPI inline void header(

             const MinimalBitsetHeader& _header) { m_header = _header; }

     RTPS_DllAPI inline void header(

             MinimalBitsetHeader&& _header) { m_header = std::move(_header); }

     RTPS_DllAPI inline const MinimalBitsetHeader& header() const { return m_header; }

     RTPS_DllAPI inline MinimalBitsetHeader& header() { return m_header; }


     RTPS_DllAPI inline void field_seq(

             const MinimalBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }

     RTPS_DllAPI inline void field_seq(

             MinimalBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }

     RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const { return m_field_seq; }

     RTPS_DllAPI inline MinimalBitfieldSeq& field_seq() { return m_field_seq; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalBitsetType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalBitsetType& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalBitsetType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     BitsetTypeFlag m_bitset_flags;

     MinimalBitsetHeader m_header;

     MinimalBitfieldSeq m_field_seq;

 };


 // --- Type Object: --------------------------------------------------

 // The types associated with each case selection must have extensibility

 // kind APPENDABLE or MUTABLE so that they can be extended in the future


 /*struct CompleteExtendedType {

     // Empty. Available for future extension

    };*/

 class CompleteExtendedType

 {

 public:


     RTPS_DllAPI CompleteExtendedType();

     RTPS_DllAPI ~CompleteExtendedType();

     RTPS_DllAPI CompleteExtendedType(

             const CompleteExtendedType& x);

     RTPS_DllAPI CompleteExtendedType(

             CompleteExtendedType&& x);

     RTPS_DllAPI CompleteExtendedType& operator=(

             const CompleteExtendedType& x);

     RTPS_DllAPI CompleteExtendedType& operator=(

             CompleteExtendedType&& x);


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteExtendedType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteExtendedType&) const { return true; }


     RTPS_DllAPI bool consistent(

             const CompleteExtendedType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


 };


 /*struct MinimalExtendedType  {

     // Empty. Available for future extension

    };*/

 class MinimalExtendedType

 {

 public:


     RTPS_DllAPI MinimalExtendedType();

     RTPS_DllAPI ~MinimalExtendedType();

     RTPS_DllAPI MinimalExtendedType(

             const MinimalExtendedType& x);

     RTPS_DllAPI MinimalExtendedType(

             MinimalExtendedType&& x);

     RTPS_DllAPI MinimalExtendedType& operator=(

             const MinimalExtendedType& x);

     RTPS_DllAPI MinimalExtendedType& operator=(

             MinimalExtendedType&& x);


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalExtendedType& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalExtendedType&) const { return true; }


     RTPS_DllAPI bool consistent(

             const MinimalExtendedType& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


 };


 class CompleteTypeObject final

 {

 public:


     RTPS_DllAPI CompleteTypeObject();

     RTPS_DllAPI ~CompleteTypeObject();

     RTPS_DllAPI CompleteTypeObject(

             const CompleteTypeObject& x);

     RTPS_DllAPI CompleteTypeObject(

             CompleteTypeObject&& x);

     RTPS_DllAPI CompleteTypeObject& operator=(

             const CompleteTypeObject& x);

     RTPS_DllAPI CompleteTypeObject& operator=(

             CompleteTypeObject&& x);

     RTPS_DllAPI void _d(

             octet __d);

     RTPS_DllAPI octet _d() const;

     RTPS_DllAPI octet& _d();


     RTPS_DllAPI void alias_type(

             CompleteAliasType _alias_type);

     RTPS_DllAPI const CompleteAliasType& alias_type() const;

     RTPS_DllAPI CompleteAliasType& alias_type();


     RTPS_DllAPI void annotation_type(

             CompleteAnnotationType _annotation_type);

     RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;

     RTPS_DllAPI CompleteAnnotationType& annotation_type();


     RTPS_DllAPI void struct_type(

             CompleteStructType _struct_type);

     RTPS_DllAPI const CompleteStructType& struct_type() const;

     RTPS_DllAPI CompleteStructType& struct_type();


     RTPS_DllAPI void union_type(

             CompleteUnionType _union_type);

     RTPS_DllAPI const CompleteUnionType& union_type() const;

     RTPS_DllAPI CompleteUnionType& union_type();


     RTPS_DllAPI void bitset_type(

             CompleteBitsetType _bitset_type);

     RTPS_DllAPI const CompleteBitsetType& bitset_type() const;

     RTPS_DllAPI CompleteBitsetType& bitset_type();


     RTPS_DllAPI void sequence_type(

             CompleteSequenceType _sequence_type);

     RTPS_DllAPI const CompleteSequenceType& sequence_type() const;

     RTPS_DllAPI CompleteSequenceType& sequence_type();


     RTPS_DllAPI void array_type(

             CompleteArrayType _array_type);

     RTPS_DllAPI const CompleteArrayType& array_type() const;

     RTPS_DllAPI CompleteArrayType& array_type();


     RTPS_DllAPI void map_type(

             CompleteMapType _map_type);

     RTPS_DllAPI const CompleteMapType& map_type() const;

     RTPS_DllAPI CompleteMapType& map_type();


     RTPS_DllAPI void enumerated_type(

             CompleteEnumeratedType _enumerated_type);

     RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;

     RTPS_DllAPI CompleteEnumeratedType& enumerated_type();


     RTPS_DllAPI void bitmask_type(

             CompleteBitmaskType _bitmask_type);

     RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;

     RTPS_DllAPI CompleteBitmaskType& bitmask_type();


     RTPS_DllAPI void extended_type(

             CompleteExtendedType _extended_type);

     RTPS_DllAPI const CompleteExtendedType& extended_type() const;

     RTPS_DllAPI CompleteExtendedType& extended_type();


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const CompleteTypeObject& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const CompleteTypeObject& other) const;


     RTPS_DllAPI bool consistent(

             const CompleteTypeObject& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     octet m__d;


     CompleteAliasType m_alias_type;

     CompleteAnnotationType m_annotation_type;

     CompleteStructType m_struct_type;

     CompleteUnionType m_union_type;

     CompleteBitsetType m_bitset_type;

     CompleteSequenceType m_sequence_type;

     CompleteArrayType m_array_type;

     CompleteMapType m_map_type;

     CompleteEnumeratedType m_enumerated_type;

     CompleteBitmaskType m_bitmask_type;

     CompleteExtendedType m_extended_type;

 };


 class MinimalTypeObject final

 {

 public:


     RTPS_DllAPI MinimalTypeObject();

     RTPS_DllAPI ~MinimalTypeObject();

     RTPS_DllAPI MinimalTypeObject(

             const MinimalTypeObject& x);

     RTPS_DllAPI MinimalTypeObject(

             MinimalTypeObject&& x);

     RTPS_DllAPI MinimalTypeObject& operator=(

             const MinimalTypeObject& x);

     RTPS_DllAPI MinimalTypeObject& operator=(

             MinimalTypeObject&& x);

     RTPS_DllAPI void _d(

             octet __d);

     RTPS_DllAPI octet _d() const;

     RTPS_DllAPI octet& _d();


     RTPS_DllAPI void alias_type(

             MinimalAliasType _alias_type);

     RTPS_DllAPI const MinimalAliasType& alias_type() const;

     RTPS_DllAPI MinimalAliasType& alias_type();


     RTPS_DllAPI void annotation_type(

             MinimalAnnotationType _annotation_type);

     RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;

     RTPS_DllAPI MinimalAnnotationType& annotation_type();


     RTPS_DllAPI void struct_type(

             MinimalStructType _struct_type);

     RTPS_DllAPI const MinimalStructType& struct_type() const;

     RTPS_DllAPI MinimalStructType& struct_type();


     RTPS_DllAPI void union_type(

             MinimalUnionType _union_type);

     RTPS_DllAPI const MinimalUnionType& union_type() const;

     RTPS_DllAPI MinimalUnionType& union_type();


     RTPS_DllAPI void bitset_type(

             MinimalBitsetType _bitset_type);

     RTPS_DllAPI const MinimalBitsetType& bitset_type() const;

     RTPS_DllAPI MinimalBitsetType& bitset_type();


     RTPS_DllAPI void sequence_type(

             MinimalSequenceType _sequence_type);

     RTPS_DllAPI const MinimalSequenceType& sequence_type() const;

     RTPS_DllAPI MinimalSequenceType& sequence_type();


     RTPS_DllAPI void array_type(

             MinimalArrayType _array_type);

     RTPS_DllAPI const MinimalArrayType& array_type() const;

     RTPS_DllAPI MinimalArrayType& array_type();


     RTPS_DllAPI void map_type(

             MinimalMapType _map_type);

     RTPS_DllAPI const MinimalMapType& map_type() const;

     RTPS_DllAPI MinimalMapType& map_type();


     RTPS_DllAPI void enumerated_type(

             MinimalEnumeratedType _enumerated_type);

     RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;

     RTPS_DllAPI MinimalEnumeratedType& enumerated_type();


     RTPS_DllAPI void bitmask_type(

             MinimalBitmaskType _bitmask_type);

     RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;

     RTPS_DllAPI MinimalBitmaskType& bitmask_type();


     RTPS_DllAPI void extended_type(

             MinimalExtendedType _extended_type);

     RTPS_DllAPI const MinimalExtendedType& extended_type() const;

     RTPS_DllAPI MinimalExtendedType& extended_type();


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const MinimalTypeObject& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const MinimalTypeObject& other) const;


     RTPS_DllAPI bool consistent(

             const MinimalTypeObject& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     octet m__d;


     MinimalAliasType m_alias_type;

     MinimalAnnotationType m_annotation_type;

     MinimalStructType m_struct_type;

     MinimalUnionType m_union_type;

     MinimalBitsetType m_bitset_type;

     MinimalSequenceType m_sequence_type;

     MinimalArrayType m_array_type;

     MinimalMapType m_map_type;

     MinimalEnumeratedType m_enumerated_type;

     MinimalBitmaskType m_bitmask_type;

     MinimalExtendedType m_extended_type;

 };

 class TypeObject

 {

 public:


     RTPS_DllAPI TypeObject();


     RTPS_DllAPI ~TypeObject();


     RTPS_DllAPI TypeObject(

             const TypeObject& x);


     RTPS_DllAPI TypeObject(

             TypeObject&& x);


     RTPS_DllAPI TypeObject& operator=(

             const TypeObject& x);


     RTPS_DllAPI TypeObject& operator=(

             TypeObject&& x);


     RTPS_DllAPI void _d(

             uint8_t __d);


     RTPS_DllAPI uint8_t _d() const;


     RTPS_DllAPI uint8_t& _d();


     RTPS_DllAPI void complete(

             const CompleteTypeObject& _complete);


     RTPS_DllAPI void complete(

             CompleteTypeObject&& _complete);


     RTPS_DllAPI const CompleteTypeObject& complete() const;


     RTPS_DllAPI CompleteTypeObject& complete();

     RTPS_DllAPI void minimal(

             const MinimalTypeObject& _minimal);


     RTPS_DllAPI void minimal(

             MinimalTypeObject&& _minimal);


     RTPS_DllAPI const MinimalTypeObject& minimal() const;


     RTPS_DllAPI MinimalTypeObject& minimal();


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeObject& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;


     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


     RTPS_DllAPI bool operator==(

             const TypeObject& other) const;


     RTPS_DllAPI bool consistent(

             const TypeObject& x,

             const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;


 private:


     uint8_t m__d;


     CompleteTypeObject m_complete;

     MinimalTypeObject m_minimal;

 };


 typedef std::vector<TypeObject> TypeObjectSeq;


 // Set of TypeObjects representing a strong component: Equivalence class

 // for the Strong Connectivity relationship (mutual reachability between

 // types).

 // Ordered by fully qualified typename lexicographic order

 typedef TypeObjectSeq StronglyConnectedComponent;


 /*struct TypeIdentifierTypeObjectPair final {

     TypeIdentifier  type_identifier;

     TypeObject      type_object;

    };*/

 class TypeIdentifierTypeObjectPair final

 {

 public:


     RTPS_DllAPI TypeIdentifierTypeObjectPair();

     RTPS_DllAPI ~TypeIdentifierTypeObjectPair();

     RTPS_DllAPI TypeIdentifierTypeObjectPair(

             const TypeIdentifierTypeObjectPair& x);

     RTPS_DllAPI TypeIdentifierTypeObjectPair(

             TypeIdentifierTypeObjectPair&& x);

     RTPS_DllAPI TypeIdentifierTypeObjectPair& operator=(

             const TypeIdentifierTypeObjectPair& x);

     RTPS_DllAPI TypeIdentifierTypeObjectPair& operator=(

             TypeIdentifierTypeObjectPair&& x);


     RTPS_DllAPI inline void type_identifier(

             const TypeIdentifier& _type_identifier) { m_type_identifier = _type_identifier; }

     RTPS_DllAPI inline void type_identifier(

             TypeIdentifier&& _type_identifier) { m_type_identifier = std::move(_type_identifier); }

     RTPS_DllAPI inline const TypeIdentifier& type_identifier() const { return m_type_identifier; }

     RTPS_DllAPI inline TypeIdentifier& type_identifier() { return m_type_identifier; }


     RTPS_DllAPI inline void type_object(

             const TypeObject& _type_object) { m_type_object = _type_object; }

     RTPS_DllAPI inline void type_object(

             TypeObject&& _type_object) { m_type_object = std::move(_type_object); }

     RTPS_DllAPI inline const TypeObject& type_object() const { return m_type_object; }

     RTPS_DllAPI inline TypeObject& type_object() { return m_type_object; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeIdentifierTypeObjectPair& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


 private:


     TypeIdentifier m_type_identifier;

     TypeObject m_type_object;

 };

 typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;


 /*struct TypeIdentifierPair final {

     TypeIdentifier  type_identifier1;

     TypeIdentifier  type_identifier2;

    };*/

 class TypeIdentifierPair final

 {

 public:


     RTPS_DllAPI TypeIdentifierPair();

     RTPS_DllAPI ~TypeIdentifierPair();

     RTPS_DllAPI TypeIdentifierPair(

             const TypeIdentifierPair& x);

     RTPS_DllAPI TypeIdentifierPair(

             TypeIdentifierPair&& x);

     RTPS_DllAPI TypeIdentifierPair& operator=(

             const TypeIdentifierPair& x);

     RTPS_DllAPI TypeIdentifierPair& operator=(

             TypeIdentifierPair&& x);


     RTPS_DllAPI inline void type_identifier1(

             const TypeIdentifier& _type_identifier1) { m_type_identifier1 = _type_identifier1; }

     RTPS_DllAPI inline void type_identifier1(

             TypeIdentifier&& _type_identifier1) { m_type_identifier1 = std::move(_type_identifier1); }

     RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const { return m_type_identifier1; }

     RTPS_DllAPI inline TypeIdentifier& type_identifier1() { return m_type_identifier1; }


     RTPS_DllAPI inline void type_identifier2(

             const TypeIdentifier& _type_identifier2) { m_type_identifier2 = _type_identifier2; }

     RTPS_DllAPI inline void type_identifier2(

             TypeIdentifier&& _type_identifier2) { m_type_identifier2 = std::move(_type_identifier2); }

     RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const { return m_type_identifier2; }

     RTPS_DllAPI inline TypeIdentifier& type_identifier2() { return m_type_identifier2; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeIdentifierPair& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


 private:


     TypeIdentifier m_type_identifier1;

     TypeIdentifier m_type_identifier2;

 };


 typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;

 /*struct TypeIdentifierWithSize {

     TypeIdentifier  type_id;

     uint32_t                typeobject_serialized_size;

    };*/

 class TypeIdentifierWithSize

 {

 public:


     RTPS_DllAPI TypeIdentifierWithSize();

     RTPS_DllAPI ~TypeIdentifierWithSize();

     RTPS_DllAPI TypeIdentifierWithSize(

             const TypeIdentifierWithSize& x);

     RTPS_DllAPI TypeIdentifierWithSize(

             TypeIdentifierWithSize&& x);

     RTPS_DllAPI TypeIdentifierWithSize& operator=(

             const TypeIdentifierWithSize& x);

     RTPS_DllAPI TypeIdentifierWithSize& operator=(

             TypeIdentifierWithSize&& x);


     RTPS_DllAPI inline void type_id(

             const TypeIdentifier& _type_id) { m_type_id = _type_id; }

     RTPS_DllAPI inline void type_id(

             TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }

     RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }

     RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }


     RTPS_DllAPI inline void typeobject_serialized_size(

             const uint32_t& _typeobject_serialized_size) { m_typeobject_serialized_size = _typeobject_serialized_size; }

     RTPS_DllAPI inline void typeobject_serialized_size(

             uint32_t&& _typeobject_serialized_size) {

         m_typeobject_serialized_size = std::move(_typeobject_serialized_size);

     }

     RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const { return m_typeobject_serialized_size; }

     RTPS_DllAPI inline uint32_t& typeobject_serialized_size() { return m_typeobject_serialized_size; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeIdentifierWithSize& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


 private:


     TypeIdentifier m_type_id;

     uint32_t m_typeobject_serialized_size;

 };


 typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;


 /*struct TypeIdentifierWithDependencies {

     TypeIdentifierWithSize            typeid_with_size;

     // The total additional types related to minimal_type

     int32_t                             dependent_typeid_count;

     TypeIdentifierWithSizeSeq  dependent_typeids;

    };*/

 class TypeIdentifierWithDependencies

 {

 public:


     RTPS_DllAPI TypeIdentifierWithDependencies();

     RTPS_DllAPI ~TypeIdentifierWithDependencies();

     RTPS_DllAPI TypeIdentifierWithDependencies(

             const TypeIdentifierWithDependencies& x);

     RTPS_DllAPI TypeIdentifierWithDependencies(

             TypeIdentifierWithDependencies&& x);

     RTPS_DllAPI TypeIdentifierWithDependencies& operator=(

             const TypeIdentifierWithDependencies& x);

     RTPS_DllAPI TypeIdentifierWithDependencies& operator=(

             TypeIdentifierWithDependencies&& x);


     RTPS_DllAPI inline void typeid_with_size(

             const TypeIdentifierWithSize& _typeid_with_size) { m_typeid_with_size = _typeid_with_size; }

     RTPS_DllAPI inline void typeid_with_size(

             TypeIdentifierWithSize&& _typeid_with_size) { m_typeid_with_size = std::move(_typeid_with_size); }

     RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const { return m_typeid_with_size; }

     RTPS_DllAPI inline TypeIdentifierWithSize& typeid_with_size() { return m_typeid_with_size; }


     RTPS_DllAPI inline void dependent_typeid_count(

             const int32_t& _dependent_typeid_count) { m_dependent_typeid_count = _dependent_typeid_count; }

     RTPS_DllAPI inline void dependent_typeid_count(

             int32_t&& _dependent_typeid_count) { m_dependent_typeid_count = std::move(_dependent_typeid_count); }

     RTPS_DllAPI inline const int32_t& dependent_typeid_count() const { return m_dependent_typeid_count; }

     RTPS_DllAPI inline int32_t& dependent_typeid_count() { return m_dependent_typeid_count; }


     RTPS_DllAPI inline void dependent_typeids(

             const TypeIdentifierWithSizeSeq& _dependent_typeids) { m_dependent_typeids = _dependent_typeids; }

     RTPS_DllAPI inline void dependent_typeids(

             TypeIdentifierWithSizeSeq&& _dependent_typeids) { m_dependent_typeids = std::move(_dependent_typeids); }

     RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const { return m_dependent_typeids; }

     RTPS_DllAPI inline TypeIdentifierWithSizeSeq& dependent_typeids() { return m_dependent_typeids; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeIdentifierWithDependencies& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


 private:


     TypeIdentifierWithSize m_typeid_with_size;

     int32_t m_dependent_typeid_count;

     TypeIdentifierWithSizeSeq m_dependent_typeids;

 };


 typedef    std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;


 // This appears in the builtin DDS topics PublicationBuiltinTopicData

 // and SubscriptionBuiltinTopicData


 /*struct TypeInformation  {

     TypeIdentifierWithDependencies minimal; // @id{0x1001}

     TypeIdentifierWithDependencies complete; // @id{0x1002}

    };*/

 class TypeInformation

 {

 public:


     RTPS_DllAPI TypeInformation();

     RTPS_DllAPI ~TypeInformation();

     RTPS_DllAPI TypeInformation(

             const TypeInformation& x);

     RTPS_DllAPI TypeInformation(

             TypeInformation&& x);

     RTPS_DllAPI TypeInformation& operator=(

             const TypeInformation& x);

     RTPS_DllAPI TypeInformation& operator=(

             TypeInformation&& x);


     RTPS_DllAPI inline void minimal(

             const TypeIdentifierWithDependencies& _minimal) { m_minimal = _minimal; }

     RTPS_DllAPI inline void minimal(

             TypeIdentifierWithDependencies&& _minimal) { m_minimal = std::move(_minimal); }

     RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const { return m_minimal; }

     RTPS_DllAPI inline TypeIdentifierWithDependencies& minimal() { return m_minimal; }


     RTPS_DllAPI inline void complete(

             const TypeIdentifierWithDependencies& _complete) { m_complete = _complete; }

     RTPS_DllAPI inline void complete(

             TypeIdentifierWithDependencies&& _complete) { m_complete = std::move(_complete); }

     RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const { return m_complete; }

     RTPS_DllAPI inline TypeIdentifierWithDependencies& complete() { return m_complete; }


     RTPS_DllAPI static size_t getCdrSerializedSize(

             const TypeInformation& data,

             size_t current_alignment = 0);

     RTPS_DllAPI void serialize(

             eprosima::fastcdr::Cdr& cdr) const;

     RTPS_DllAPI void deserialize(

             eprosima::fastcdr::Cdr& cdr);


 private:


     TypeIdentifierWithDependencies m_minimal;

     TypeIdentifierWithDependencies m_complete;

 };


 typedef std::vector<TypeInformation> TypeInformationSeq;


 } // namespace types

 } // namespace fastrtps

 } // namespace eprosima


 #endif // TYPES_TYPE_OBJECT_H

eprosima::fastrtps::types::AnnotationParameterValue
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:149

eprosima::fastrtps::types::AppliedBuiltinMemberAnnotations
Definition: AnnotationParameterValue.h:1221

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations
Definition: TypeObject.h:331

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
RTPS_DllAPI AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::verbatim
RTPS_DllAPI const AppliedVerbatimAnnotation & verbatim() const
Definition: TypeObject.h:349

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
RTPS_DllAPI AppliedBuiltinTypeAnnotations()

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::~AppliedBuiltinTypeAnnotations
RTPS_DllAPI ~AppliedBuiltinTypeAnnotations()

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::consistent
RTPS_DllAPI bool consistent(const AppliedBuiltinTypeAnnotations &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::operator=
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(AppliedBuiltinTypeAnnotations &&x)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
RTPS_DllAPI AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedBuiltinTypeAnnotations &data, size_t current_alignment=0)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::operator=
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::verbatim
RTPS_DllAPI void verbatim(AppliedVerbatimAnnotation &&_verbatim)
Definition: TypeObject.h:347

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::verbatim
RTPS_DllAPI AppliedVerbatimAnnotation & verbatim()
Definition: TypeObject.h:350

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::operator==
RTPS_DllAPI bool operator==(const AppliedBuiltinTypeAnnotations &other) const

eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::verbatim
RTPS_DllAPI void verbatim(const AppliedVerbatimAnnotation &_verbatim)
Definition: TypeObject.h:345

eprosima::fastrtps::types::AppliedVerbatimAnnotation
Definition: AnnotationParameterValue.h:1109

eprosima::fastrtps::types::CommonAliasBody
Definition: TypeObject.h:1695

eprosima::fastrtps::types::CommonAliasBody::related_flags
RTPS_DllAPI AliasMemberFlag & related_flags()
Definition: TypeObject.h:1714

eprosima::fastrtps::types::CommonAliasBody::~CommonAliasBody
RTPS_DllAPI ~CommonAliasBody()

eprosima::fastrtps::types::CommonAliasBody::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAliasBody &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonAliasBody::operator=
RTPS_DllAPI CommonAliasBody & operator=(CommonAliasBody &&x)

eprosima::fastrtps::types::CommonAliasBody::related_type
RTPS_DllAPI TypeIdentifier & related_type()
Definition: TypeObject.h:1721

eprosima::fastrtps::types::CommonAliasBody::CommonAliasBody
RTPS_DllAPI CommonAliasBody(const CommonAliasBody &x)

eprosima::fastrtps::types::CommonAliasBody::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonAliasBody::CommonAliasBody
RTPS_DllAPI CommonAliasBody(CommonAliasBody &&x)

eprosima::fastrtps::types::CommonAliasBody::related_flags
RTPS_DllAPI const AliasMemberFlag & related_flags() const
Definition: TypeObject.h:1713

eprosima::fastrtps::types::CommonAliasBody::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonAliasBody::related_type
RTPS_DllAPI const TypeIdentifier & related_type() const
Definition: TypeObject.h:1720

eprosima::fastrtps::types::CommonAliasBody::related_flags
RTPS_DllAPI void related_flags(AliasMemberFlag &&_related_flags)
Definition: TypeObject.h:1711

eprosima::fastrtps::types::CommonAliasBody::CommonAliasBody
RTPS_DllAPI CommonAliasBody()

eprosima::fastrtps::types::CommonAliasBody::related_flags
RTPS_DllAPI void related_flags(const AliasMemberFlag &_related_flags)
Definition: TypeObject.h:1709

eprosima::fastrtps::types::CommonAliasBody::operator=
RTPS_DllAPI CommonAliasBody & operator=(const CommonAliasBody &x)

eprosima::fastrtps::types::CommonAliasBody::operator==
RTPS_DllAPI bool operator==(const CommonAliasBody &other) const

eprosima::fastrtps::types::CommonAliasBody::related_type
RTPS_DllAPI void related_type(TypeIdentifier &&_related_type)
Definition: TypeObject.h:1718

eprosima::fastrtps::types::CommonAliasBody::related_type
RTPS_DllAPI void related_type(const TypeIdentifier &_related_type)
Definition: TypeObject.h:1716

eprosima::fastrtps::types::CommonAnnotationParameter
Definition: TypeObject.h:1302

eprosima::fastrtps::types::CommonAnnotationParameter::member_flags
RTPS_DllAPI const AnnotationParameterFlag & member_flags() const
Definition: TypeObject.h:1320

eprosima::fastrtps::types::CommonAnnotationParameter::member_flags
RTPS_DllAPI AnnotationParameterFlag & member_flags()
Definition: TypeObject.h:1321

eprosima::fastrtps::types::CommonAnnotationParameter::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAnnotationParameter &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonAnnotationParameter::CommonAnnotationParameter
RTPS_DllAPI CommonAnnotationParameter()

eprosima::fastrtps::types::CommonAnnotationParameter::CommonAnnotationParameter
RTPS_DllAPI CommonAnnotationParameter(CommonAnnotationParameter &&x)

eprosima::fastrtps::types::CommonAnnotationParameter::member_type_id
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:1325

eprosima::fastrtps::types::CommonAnnotationParameter::member_flags
RTPS_DllAPI void member_flags(const AnnotationParameterFlag &_member_flags)
Definition: TypeObject.h:1316

eprosima::fastrtps::types::CommonAnnotationParameter::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonAnnotationParameter::CommonAnnotationParameter
RTPS_DllAPI CommonAnnotationParameter(const CommonAnnotationParameter &x)

eprosima::fastrtps::types::CommonAnnotationParameter::member_type_id
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:1323

eprosima::fastrtps::types::CommonAnnotationParameter::member_flags
RTPS_DllAPI void member_flags(AnnotationParameterFlag &&_member_flags)
Definition: TypeObject.h:1318

eprosima::fastrtps::types::CommonAnnotationParameter::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonAnnotationParameter::~CommonAnnotationParameter
RTPS_DllAPI ~CommonAnnotationParameter()

eprosima::fastrtps::types::CommonAnnotationParameter::operator=
RTPS_DllAPI CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)

eprosima::fastrtps::types::CommonAnnotationParameter::member_type_id
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:1328

eprosima::fastrtps::types::CommonAnnotationParameter::consistent
RTPS_DllAPI bool consistent(const CommonAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::CommonAnnotationParameter::operator==
RTPS_DllAPI bool operator==(const CommonAnnotationParameter &other) const

eprosima::fastrtps::types::CommonAnnotationParameter::member_type_id
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:1327

eprosima::fastrtps::types::CommonAnnotationParameter::operator=
RTPS_DllAPI CommonAnnotationParameter & operator=(CommonAnnotationParameter &&x)

eprosima::fastrtps::types::CommonArrayHeader
Definition: TypeObject.h:2535

eprosima::fastrtps::types::CommonArrayHeader::operator=
RTPS_DllAPI CommonArrayHeader & operator=(CommonArrayHeader &&x)

eprosima::fastrtps::types::CommonArrayHeader::consistent
RTPS_DllAPI bool consistent(const CommonArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::CommonArrayHeader::bound_seq
RTPS_DllAPI LBoundSeq & bound_seq()
Definition: TypeObject.h:2554

eprosima::fastrtps::types::CommonArrayHeader::bound_seq
RTPS_DllAPI void bound_seq(const LBoundSeq &_bound_seq)
Definition: TypeObject.h:2549

eprosima::fastrtps::types::CommonArrayHeader::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonArrayHeader::CommonArrayHeader
RTPS_DllAPI CommonArrayHeader(const CommonArrayHeader &x)

eprosima::fastrtps::types::CommonArrayHeader::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonArrayHeader &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonArrayHeader::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonArrayHeader::~CommonArrayHeader
RTPS_DllAPI ~CommonArrayHeader()

eprosima::fastrtps::types::CommonArrayHeader::bound_seq
RTPS_DllAPI const LBoundSeq & bound_seq() const
Definition: TypeObject.h:2553

eprosima::fastrtps::types::CommonArrayHeader::CommonArrayHeader
RTPS_DllAPI CommonArrayHeader(CommonArrayHeader &&x)

eprosima::fastrtps::types::CommonArrayHeader::bound_seq
RTPS_DllAPI void bound_seq(LBoundSeq &&_bound_seq)
Definition: TypeObject.h:2551

eprosima::fastrtps::types::CommonArrayHeader::operator=
RTPS_DllAPI CommonArrayHeader & operator=(const CommonArrayHeader &x)

eprosima::fastrtps::types::CommonArrayHeader::operator==
RTPS_DllAPI bool operator==(const CommonArrayHeader &other) const

eprosima::fastrtps::types::CommonArrayHeader::CommonArrayHeader
RTPS_DllAPI CommonArrayHeader()

eprosima::fastrtps::types::CommonBitfield
Definition: TypeObject.h:3741

eprosima::fastrtps::types::CommonBitfield::flags
RTPS_DllAPI const BitsetMemberFlag & flags() const
Definition: TypeObject.h:3766

eprosima::fastrtps::types::CommonBitfield::bitcount
RTPS_DllAPI void bitcount(octet &&_bitcount)
Definition: TypeObject.h:3771

eprosima::fastrtps::types::CommonBitfield::CommonBitfield
RTPS_DllAPI CommonBitfield(const CommonBitfield &x)

eprosima::fastrtps::types::CommonBitfield::holder_type
RTPS_DllAPI void holder_type(TypeKind &&_holder_type)
Definition: TypeObject.h:3778

eprosima::fastrtps::types::CommonBitfield::position
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3760

eprosima::fastrtps::types::CommonBitfield::operator=
RTPS_DllAPI CommonBitfield & operator=(const CommonBitfield &x)

eprosima::fastrtps::types::CommonBitfield::CommonBitfield
RTPS_DllAPI CommonBitfield(CommonBitfield &&x)

eprosima::fastrtps::types::CommonBitfield::~CommonBitfield
RTPS_DllAPI ~CommonBitfield()

eprosima::fastrtps::types::CommonBitfield::bitcount
RTPS_DllAPI const octet & bitcount() const
Definition: TypeObject.h:3773

eprosima::fastrtps::types::CommonBitfield::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonBitfield::consistent
RTPS_DllAPI bool consistent(const CommonBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::CommonBitfield::operator==
RTPS_DllAPI bool operator==(const CommonBitfield &other) const

eprosima::fastrtps::types::CommonBitfield::holder_type
RTPS_DllAPI void holder_type(const TypeKind &_holder_type)
Definition: TypeObject.h:3776

eprosima::fastrtps::types::CommonBitfield::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonBitfield::flags
RTPS_DllAPI BitsetMemberFlag & flags()
Definition: TypeObject.h:3767

eprosima::fastrtps::types::CommonBitfield::position
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3759

eprosima::fastrtps::types::CommonBitfield::CommonBitfield
RTPS_DllAPI CommonBitfield()

eprosima::fastrtps::types::CommonBitfield::holder_type
RTPS_DllAPI TypeKind & holder_type()
Definition: TypeObject.h:3781

eprosima::fastrtps::types::CommonBitfield::bitcount
RTPS_DllAPI void bitcount(const octet &_bitcount)
Definition: TypeObject.h:3769

eprosima::fastrtps::types::CommonBitfield::operator=
RTPS_DllAPI CommonBitfield & operator=(CommonBitfield &&x)

eprosima::fastrtps::types::CommonBitfield::position
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3757

eprosima::fastrtps::types::CommonBitfield::position
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3755

eprosima::fastrtps::types::CommonBitfield::holder_type
RTPS_DllAPI const TypeKind & holder_type() const
Definition: TypeObject.h:3780

eprosima::fastrtps::types::CommonBitfield::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitfield &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonBitfield::bitcount
RTPS_DllAPI octet & bitcount()
Definition: TypeObject.h:3774

eprosima::fastrtps::types::CommonBitfield::flags
RTPS_DllAPI void flags(BitsetMemberFlag &&_flags)
Definition: TypeObject.h:3764

eprosima::fastrtps::types::CommonBitfield::flags
RTPS_DllAPI void flags(const BitsetMemberFlag &_flags)
Definition: TypeObject.h:3762

eprosima::fastrtps::types::CommonBitflag
Definition: TypeObject.h:3399

eprosima::fastrtps::types::CommonBitflag::CommonBitflag
RTPS_DllAPI CommonBitflag(const CommonBitflag &x)

eprosima::fastrtps::types::CommonBitflag::operator=
RTPS_DllAPI CommonBitflag & operator=(const CommonBitflag &x)

eprosima::fastrtps::types::CommonBitflag::position
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3418

eprosima::fastrtps::types::CommonBitflag::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitflag &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonBitflag::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonBitflag::operator=
RTPS_DllAPI CommonBitflag & operator=(CommonBitflag &&x)

eprosima::fastrtps::types::CommonBitflag::CommonBitflag
RTPS_DllAPI CommonBitflag(CommonBitflag &&x)

eprosima::fastrtps::types::CommonBitflag::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonBitflag::flags
RTPS_DllAPI const BitflagFlag & flags() const
Definition: TypeObject.h:3424

eprosima::fastrtps::types::CommonBitflag::position
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3417

eprosima::fastrtps::types::CommonBitflag::flags
RTPS_DllAPI void flags(BitflagFlag &&_flags)
Definition: TypeObject.h:3422

eprosima::fastrtps::types::CommonBitflag::consistent
RTPS_DllAPI bool consistent(const CommonBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::CommonBitflag::flags
RTPS_DllAPI void flags(const BitflagFlag &_flags)
Definition: TypeObject.h:3420

eprosima::fastrtps::types::CommonBitflag::CommonBitflag
RTPS_DllAPI CommonBitflag()

eprosima::fastrtps::types::CommonBitflag::position
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3415

eprosima::fastrtps::types::CommonBitflag::position
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3413

eprosima::fastrtps::types::CommonBitflag::operator==
RTPS_DllAPI bool operator==(const CommonBitflag &other) const

eprosima::fastrtps::types::CommonBitflag::flags
RTPS_DllAPI BitflagFlag & flags()
Definition: TypeObject.h:3425

eprosima::fastrtps::types::CommonBitflag::~CommonBitflag
RTPS_DllAPI ~CommonBitflag()

eprosima::fastrtps::types::CommonBitmaskHeader
Definition: TypeObject.h:3564

eprosima::fastrtps::types::CommonBitmaskHeader::bit_bound
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:3578

eprosima::fastrtps::types::CommonBitmaskHeader::~CommonBitmaskHeader
RTPS_DllAPI ~CommonBitmaskHeader()

eprosima::fastrtps::types::CommonBitmaskHeader::operator=
RTPS_DllAPI CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)

eprosima::fastrtps::types::CommonBitmaskHeader::consistent
RTPS_DllAPI bool consistent(const CommonBitmaskHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const

eprosima::fastrtps::types::CommonBitmaskHeader::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonBitmaskHeader::bit_bound
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:3583

eprosima::fastrtps::types::CommonBitmaskHeader::CommonBitmaskHeader
RTPS_DllAPI CommonBitmaskHeader()

eprosima::fastrtps::types::CommonBitmaskHeader::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonBitmaskHeader::bit_bound
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:3580

eprosima::fastrtps::types::CommonBitmaskHeader::CommonBitmaskHeader
RTPS_DllAPI CommonBitmaskHeader(const CommonBitmaskHeader &x)

eprosima::fastrtps::types::CommonBitmaskHeader::CommonBitmaskHeader
RTPS_DllAPI CommonBitmaskHeader(CommonBitmaskHeader &&x)

eprosima::fastrtps::types::CommonBitmaskHeader::bit_bound
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:3582

eprosima::fastrtps::types::CommonBitmaskHeader::operator==
RTPS_DllAPI bool operator==(const CommonBitmaskHeader &other) const

eprosima::fastrtps::types::CommonBitmaskHeader::operator=
RTPS_DllAPI CommonBitmaskHeader & operator=(CommonBitmaskHeader &&x)

eprosima::fastrtps::types::CommonBitmaskHeader::getCdrSerializedSize
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitmaskHeader &data, size_t current_alignment=0)

eprosima::fastrtps::types::CommonCollectionElement
Definition: TypeObject.h:2111

eprosima::fastrtps::types::CommonCollectionElement::element_flags
RTPS_DllAPI void element_flags(const CollectionElementFlag &_element_flags)
Definition: TypeObject.h:2125

eprosima::fastrtps::types::CommonCollectionElement::CommonCollectionElement
RTPS_DllAPI CommonCollectionElement(CommonCollectionElement &&x)

eprosima::fastrtps::types::CommonCollectionElement::operator==
RTPS_DllAPI bool operator==(const CommonCollectionElement &other) const

eprosima::fastrtps::types::CommonCollectionElement::type
RTPS_DllAPI const TypeIdentifier & type() const
Definition: TypeObject.h:2136

eprosima::fastrtps::types::CommonCollectionElement::type
RTPS_DllAPI void type(TypeIdentifier &&_type)
Definition: TypeObject.h:2134

eprosima::fastrtps::types::CommonCollectionElement::CommonCollectionElement
RTPS_DllAPI CommonCollectionElement()

eprosima::fastrtps::types::CommonCollectionElement::element_flags
RTPS_DllAPI void element_flags(CollectionElementFlag &&_element_flags)
Definition: TypeObject.h:2127

eprosima::fastrtps::types::CommonCollectionElement::operator=
RTPS_DllAPI CommonCollectionElement & operator=(CommonCollectionElement &&x)

eprosima::fastrtps::types::CommonCollectionElement::deserialize
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)

eprosima::fastrtps::types::CommonCollectionElement::element_flags
RTPS_DllAPI CollectionElementFlag & element_flags()
Definition: TypeObject.h:2130

eprosima::fastrtps::types::CommonCollectionElement::type
RTPS_DllAPI TypeIdentifier & type()
Definition: TypeObject.h:2137

eprosima::fastrtps::types::CommonCollectionElement::element_flags
RTPS_DllAPI const CollectionElementFlag & element_flags() const
Definition: TypeObject.h:2129

eprosima::fastrtps::types::CommonCollectionElement::serialize
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const

eprosima::fastrtps::types::CommonCollectionElement::CommonCollectionElement
RTPS_DllAPI CommonCollectionElement(const CommonCollectionElement &x)

eprosima::fastrtps::types::CommonCollectionElement::operator=
RTPS_DllAPI CommonCollectionEl