testTypeObjectSupport.cxx

// Copyright 2016 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.

/*!
 * @file testTypeObjectSupport.cxx
 * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file
 *
 * This file was generated by the tool fastddsgen.
 */

#include "testTypeObjectSupport.hpp"

#include <mutex>
#include <string>

#include <fastcdr/xcdr/external.hpp>
#include <fastcdr/xcdr/optional.hpp>
#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
#include <fastdds/dds/log/Log.hpp>
#include <fastdds/dds/xtypes/common.hpp>
#include <fastdds/dds/xtypes/type_representation/ITypeObjectRegistry.hpp>
#include <fastdds/dds/xtypes/type_representation/TypeObject.hpp>
#include <fastdds/dds/xtypes/type_representation/TypeObjectUtils.hpp>

#include "test.hpp"


using namespace eprosima::fastdds::dds::xtypes;

// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_HelloSecurity_type_identifier(
        TypeIdentifierPair& type_ids_HelloSecurity)
{

    ReturnCode_t return_code_HelloSecurity {eprosima::fastdds::dds::RETCODE_OK};
    return_code_HelloSecurity =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "HelloSecurity", type_ids_HelloSecurity);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_HelloSecurity)
    {
        StructTypeFlag struct_flags_HelloSecurity = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_HelloSecurity = "HelloSecurity";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_HelloSecurity;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_HelloSecurity;
        CompleteTypeDetail detail_HelloSecurity = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_HelloSecurity, ann_custom_HelloSecurity, type_name_HelloSecurity.to_string());
        CompleteStructHeader header_HelloSecurity;
        header_HelloSecurity = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_HelloSecurity);
        CompleteStructMemberSeq member_seq_HelloSecurity;
        {
            TypeIdentifierPair type_ids_securityData;
            ReturnCode_t return_code_securityData {eprosima::fastdds::dds::RETCODE_OK};
            return_code_securityData =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_securityData);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_securityData)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_securityData))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_securityData = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_securityData = 0x00000000;
            bool common_securityData_ec {false};
            CommonStructMember common_securityData {TypeObjectUtils::build_common_struct_member(member_id_securityData, member_flags_securityData, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_securityData, common_securityData_ec))};
            if (!common_securityData_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure securityData member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_securityData = "securityData";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_securityData;
            ann_custom_HelloSecurity.reset();
            CompleteMemberDetail detail_securityData = TypeObjectUtils::build_complete_member_detail(name_securityData, member_ann_builtin_securityData, ann_custom_HelloSecurity);
            CompleteStructMember member_securityData = TypeObjectUtils::build_complete_struct_member(common_securityData, detail_securityData);
            TypeObjectUtils::add_complete_struct_member(member_seq_HelloSecurity, member_securityData);
        }
        CompleteStructType struct_type_HelloSecurity = TypeObjectUtils::build_complete_struct_type(struct_flags_HelloSecurity, header_HelloSecurity, member_seq_HelloSecurity);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_HelloSecurity, type_name_HelloSecurity.to_string(), type_ids_HelloSecurity))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "HelloSecurity already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_OneMessage_type_identifier(
        TypeIdentifierPair& type_ids_OneMessage)
{

    ReturnCode_t return_code_OneMessage {eprosima::fastdds::dds::RETCODE_OK};
    return_code_OneMessage =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "OneMessage", type_ids_OneMessage);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_OneMessage)
    {
        StructTypeFlag struct_flags_OneMessage = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_OneMessage = "OneMessage";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_OneMessage;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_OneMessage;
        CompleteTypeDetail detail_OneMessage = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_OneMessage, ann_custom_OneMessage, type_name_OneMessage.to_string());
        CompleteStructHeader header_OneMessage;
        header_OneMessage = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_OneMessage);
        CompleteStructMemberSeq member_seq_OneMessage;
        {
            TypeIdentifierPair type_ids_a;
            ReturnCode_t return_code_a {eprosima::fastdds::dds::RETCODE_OK};
            return_code_a =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int16_t", type_ids_a);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_a)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "a Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_a = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_a = 0x00000000;
            bool common_a_ec {false};
            CommonStructMember common_a {TypeObjectUtils::build_common_struct_member(member_id_a, member_flags_a, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_a, common_a_ec))};
            if (!common_a_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure a member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_a = "a";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_a;
            ann_custom_OneMessage.reset();
            CompleteMemberDetail detail_a = TypeObjectUtils::build_complete_member_detail(name_a, member_ann_builtin_a, ann_custom_OneMessage);
            CompleteStructMember member_a = TypeObjectUtils::build_complete_struct_member(common_a, detail_a);
            TypeObjectUtils::add_complete_struct_member(member_seq_OneMessage, member_a);
        }
        {
            TypeIdentifierPair type_ids_b;
            ReturnCode_t return_code_b {eprosima::fastdds::dds::RETCODE_OK};
            return_code_b =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_b);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_b)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "b Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_b = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_b = 0x00000001;
            bool common_b_ec {false};
            CommonStructMember common_b {TypeObjectUtils::build_common_struct_member(member_id_b, member_flags_b, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_b, common_b_ec))};
            if (!common_b_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure b member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_b = "b";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_b;
            ann_custom_OneMessage.reset();
            CompleteMemberDetail detail_b = TypeObjectUtils::build_complete_member_detail(name_b, member_ann_builtin_b, ann_custom_OneMessage);
            CompleteStructMember member_b = TypeObjectUtils::build_complete_struct_member(common_b, detail_b);
            TypeObjectUtils::add_complete_struct_member(member_seq_OneMessage, member_b);
        }
        {
            TypeIdentifierPair type_ids_sequenceTest;
            ReturnCode_t return_code_sequenceTest {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sequenceTest =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_sequence_int16_t_unbounded", type_ids_sequenceTest);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sequenceTest)
            {
                return_code_sequenceTest =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "_int16_t", type_ids_sequenceTest);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_sequenceTest)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
                    return;
                }
                bool element_identifier_anonymous_sequence_int16_t_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_sequence_int16_t_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sequenceTest, element_identifier_anonymous_sequence_int16_t_unbounded_ec))};
                if (!element_identifier_anonymous_sequence_int16_t_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_sequence_int16_t_unbounded = EK_COMPLETE;
                if (TK_NONE == type_ids_sequenceTest.type_identifier2()._d())
                {
                    equiv_kind_anonymous_sequence_int16_t_unbounded = EK_BOTH;
                }
                CollectionElementFlag element_flags_anonymous_sequence_int16_t_unbounded = 0;
                PlainCollectionHeader header_anonymous_sequence_int16_t_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_int16_t_unbounded, element_flags_anonymous_sequence_int16_t_unbounded);
                {
                    SBound bound = 0;
                    PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_int16_t_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_int16_t_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_int16_t_unbounded", type_ids_sequenceTest))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_sequence_int16_t_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_sequenceTest = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sequenceTest = 0x00000002;
            bool common_sequenceTest_ec {false};
            CommonStructMember common_sequenceTest {TypeObjectUtils::build_common_struct_member(member_id_sequenceTest, member_flags_sequenceTest, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sequenceTest, common_sequenceTest_ec))};
            if (!common_sequenceTest_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sequenceTest member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sequenceTest = "sequenceTest";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sequenceTest;
            ann_custom_OneMessage.reset();
            CompleteMemberDetail detail_sequenceTest = TypeObjectUtils::build_complete_member_detail(name_sequenceTest, member_ann_builtin_sequenceTest, ann_custom_OneMessage);
            CompleteStructMember member_sequenceTest = TypeObjectUtils::build_complete_struct_member(common_sequenceTest, detail_sequenceTest);
            TypeObjectUtils::add_complete_struct_member(member_seq_OneMessage, member_sequenceTest);
        }
        CompleteStructType struct_type_OneMessage = TypeObjectUtils::build_complete_struct_type(struct_flags_OneMessage, header_OneMessage, member_seq_OneMessage);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_OneMessage, type_name_OneMessage.to_string(), type_ids_OneMessage))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "OneMessage already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_TwoMessage_type_identifier(
        TypeIdentifierPair& type_ids_TwoMessage)
{

    ReturnCode_t return_code_TwoMessage {eprosima::fastdds::dds::RETCODE_OK};
    return_code_TwoMessage =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "TwoMessage", type_ids_TwoMessage);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_TwoMessage)
    {
        StructTypeFlag struct_flags_TwoMessage = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_TwoMessage = "TwoMessage";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_TwoMessage;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_TwoMessage;
        CompleteTypeDetail detail_TwoMessage = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_TwoMessage, ann_custom_TwoMessage, type_name_TwoMessage.to_string());
        CompleteStructHeader header_TwoMessage;
        header_TwoMessage = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_TwoMessage);
        CompleteStructMemberSeq member_seq_TwoMessage;
        {
            TypeIdentifierPair type_ids_sequenceTest;
            ReturnCode_t return_code_sequenceTest {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sequenceTest =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_sequence_int16_t_unbounded", type_ids_sequenceTest);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sequenceTest)
            {
                return_code_sequenceTest =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "_int16_t", type_ids_sequenceTest);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_sequenceTest)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
                    return;
                }
                bool element_identifier_anonymous_sequence_int16_t_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_sequence_int16_t_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sequenceTest, element_identifier_anonymous_sequence_int16_t_unbounded_ec))};
                if (!element_identifier_anonymous_sequence_int16_t_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_sequence_int16_t_unbounded = EK_COMPLETE;
                if (TK_NONE == type_ids_sequenceTest.type_identifier2()._d())
                {
                    equiv_kind_anonymous_sequence_int16_t_unbounded = EK_BOTH;
                }
                CollectionElementFlag element_flags_anonymous_sequence_int16_t_unbounded = 0;
                PlainCollectionHeader header_anonymous_sequence_int16_t_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_int16_t_unbounded, element_flags_anonymous_sequence_int16_t_unbounded);
                {
                    SBound bound = 0;
                    PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_int16_t_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_int16_t_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_int16_t_unbounded", type_ids_sequenceTest))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_sequence_int16_t_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_sequenceTest = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sequenceTest = 0x00000000;
            bool common_sequenceTest_ec {false};
            CommonStructMember common_sequenceTest {TypeObjectUtils::build_common_struct_member(member_id_sequenceTest, member_flags_sequenceTest, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sequenceTest, common_sequenceTest_ec))};
            if (!common_sequenceTest_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sequenceTest member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sequenceTest = "sequenceTest";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sequenceTest;
            ann_custom_TwoMessage.reset();
            CompleteMemberDetail detail_sequenceTest = TypeObjectUtils::build_complete_member_detail(name_sequenceTest, member_ann_builtin_sequenceTest, ann_custom_TwoMessage);
            CompleteStructMember member_sequenceTest = TypeObjectUtils::build_complete_struct_member(common_sequenceTest, detail_sequenceTest);
            TypeObjectUtils::add_complete_struct_member(member_seq_TwoMessage, member_sequenceTest);
        }
        {
            TypeIdentifierPair type_ids_mapTest;
            ReturnCode_t return_code_mapTest {eprosima::fastdds::dds::RETCODE_OK};
            return_code_mapTest =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_map_char_uint64_t_unbounded", type_ids_mapTest);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_mapTest)
            {
                return_code_mapTest =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "_uint64_t", type_ids_mapTest);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_mapTest)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "Map element TypeIdentifier unknown to TypeObjectRegistry.");
                    return;
                }
                bool element_identifier_anonymous_map_char_uint64_t_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_map_char_uint64_t_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_mapTest, element_identifier_anonymous_map_char_uint64_t_unbounded_ec))};
                if (!element_identifier_anonymous_map_char_uint64_t_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_char_uint64_t_unbounded inconsistent element TypeIdentifier.");
                    return;
                }
                return_code_mapTest =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "_char", type_ids_mapTest);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_mapTest)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "Map key TypeIdentifier unknown to TypeObjectRegistry.");
                    return;
                }
                bool key_identifier_anonymous_map_char_uint64_t_unbounded_ec {false};
                TypeIdentifier* key_identifier_anonymous_map_char_uint64_t_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_mapTest, key_identifier_anonymous_map_char_uint64_t_unbounded_ec))};
                if (!key_identifier_anonymous_map_char_uint64_t_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_char_uint64_t_unbounded inconsistent key TypeIdentifier.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_map_char_uint64_t_unbounded = EK_BOTH;
                if ((EK_COMPLETE == key_identifier_anonymous_map_char_uint64_t_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->_d()) ||
                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->seq_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->seq_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->array_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->array_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->map_sdefn().header().equiv_kind())) ||
                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_char_uint64_t_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_char_uint64_t_unbounded->map_ldefn().header().equiv_kind())))
                {
                    equiv_kind_anonymous_map_char_uint64_t_unbounded = EK_COMPLETE;
                }
                CollectionElementFlag element_flags_anonymous_map_char_uint64_t_unbounded = 0;
                CollectionElementFlag key_flags_anonymous_map_char_uint64_t_unbounded = 0;
                PlainCollectionHeader header_anonymous_map_char_uint64_t_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_char_uint64_t_unbounded, element_flags_anonymous_map_char_uint64_t_unbounded);
                {
                    SBound bound = 0;
                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_char_uint64_t_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_char_uint64_t_unbounded), key_flags_anonymous_map_char_uint64_t_unbounded,
                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_char_uint64_t_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_char_uint64_t_unbounded", type_ids_mapTest))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_map_char_uint64_t_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_mapTest = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_mapTest = 0x00000001;
            bool common_mapTest_ec {false};
            CommonStructMember common_mapTest {TypeObjectUtils::build_common_struct_member(member_id_mapTest, member_flags_mapTest, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_mapTest, common_mapTest_ec))};
            if (!common_mapTest_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure mapTest member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_mapTest = "mapTest";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_mapTest;
            ann_custom_TwoMessage.reset();
            CompleteMemberDetail detail_mapTest = TypeObjectUtils::build_complete_member_detail(name_mapTest, member_ann_builtin_mapTest, ann_custom_TwoMessage);
            CompleteStructMember member_mapTest = TypeObjectUtils::build_complete_struct_member(common_mapTest, detail_mapTest);
            TypeObjectUtils::add_complete_struct_member(member_seq_TwoMessage, member_mapTest);
        }
        CompleteStructType struct_type_TwoMessage = TypeObjectUtils::build_complete_struct_type(struct_flags_TwoMessage, header_TwoMessage, member_seq_TwoMessage);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_TwoMessage, type_name_TwoMessage.to_string(), type_ids_TwoMessage))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "TwoMessage already registered in TypeObjectRegistry for a different type.");
        }
    }
}