// 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 DDSSampleMachineTypeObjectSupport.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 "DDSSampleMachineTypeObjectSupport.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 "DDSSampleMachine.hpp"


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

namespace SampleModule {
void register_CommandState_type_identifier(
        TypeIdentifierPair& type_ids_CommandState)
{
    ReturnCode_t return_code_CommandState {eprosima::fastdds::dds::RETCODE_OK};
    return_code_CommandState =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::CommandState", type_ids_CommandState);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_CommandState)
    {
        EnumTypeFlag enum_flags_CommandState = 0;
        BitBound bit_bound_CommandState = 32;
        CommonEnumeratedHeader common_CommandState = TypeObjectUtils::build_common_enumerated_header(bit_bound_CommandState);
        QualifiedTypeName type_name_CommandState = "SampleModule::CommandState";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_CommandState;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_CommandState;
        CompleteTypeDetail detail_CommandState = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_CommandState, ann_custom_CommandState, type_name_CommandState.to_string());
        CompleteEnumeratedHeader header_CommandState = TypeObjectUtils::build_complete_enumerated_header(common_CommandState, detail_CommandState);
        CompleteEnumeratedLiteralSeq literal_seq_CommandState;
        {
            EnumeratedLiteralFlag flags_STOP = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_STOP = TypeObjectUtils::build_common_enumerated_literal(0, flags_STOP);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_STOP;
            ann_custom_CommandState.reset();
            MemberName name_STOP = "STOP";
            CompleteMemberDetail detail_STOP = TypeObjectUtils::build_complete_member_detail(name_STOP, member_ann_builtin_STOP, ann_custom_CommandState);
            CompleteEnumeratedLiteral literal_STOP = TypeObjectUtils::build_complete_enumerated_literal(common_STOP, detail_STOP);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_CommandState, literal_STOP);
        }
        {
            EnumeratedLiteralFlag flags_START = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_START = TypeObjectUtils::build_common_enumerated_literal(1, flags_START);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_START;
            ann_custom_CommandState.reset();
            MemberName name_START = "START";
            CompleteMemberDetail detail_START = TypeObjectUtils::build_complete_member_detail(name_START, member_ann_builtin_START, ann_custom_CommandState);
            CompleteEnumeratedLiteral literal_START = TypeObjectUtils::build_complete_enumerated_literal(common_START, detail_START);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_CommandState, literal_START);
        }
        CompleteEnumeratedType enumerated_type_CommandState = TypeObjectUtils::build_complete_enumerated_type(enum_flags_CommandState, header_CommandState,
                literal_seq_CommandState);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_enumerated_type_object(enumerated_type_CommandState, type_name_CommandState.to_string(), type_ids_CommandState))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                "SampleModule::CommandState already registered in TypeObjectRegistry for a different type.");
        }
    }
}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_SampleConfig_type_identifier(
        TypeIdentifierPair& type_ids_SampleConfig)
{

    ReturnCode_t return_code_SampleConfig {eprosima::fastdds::dds::RETCODE_OK};
    return_code_SampleConfig =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::SampleConfig", type_ids_SampleConfig);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SampleConfig)
    {
        StructTypeFlag struct_flags_SampleConfig = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_SampleConfig = "SampleModule::SampleConfig";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SampleConfig;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SampleConfig;
        CompleteTypeDetail detail_SampleConfig = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SampleConfig, ann_custom_SampleConfig, type_name_SampleConfig.to_string());
        CompleteStructHeader header_SampleConfig;
        header_SampleConfig = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SampleConfig);
        CompleteStructMemberSeq member_seq_SampleConfig;
        {
            TypeIdentifierPair type_ids_unifiedDepth;
            ReturnCode_t return_code_unifiedDepth {eprosima::fastdds::dds::RETCODE_OK};
            return_code_unifiedDepth =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_unifiedDepth);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_unifiedDepth)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "unifiedDepth Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_unifiedDepth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_unifiedDepth = 0x00000000;
            bool common_unifiedDepth_ec {false};
            CommonStructMember common_unifiedDepth {TypeObjectUtils::build_common_struct_member(member_id_unifiedDepth, member_flags_unifiedDepth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unifiedDepth, common_unifiedDepth_ec))};
            if (!common_unifiedDepth_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unifiedDepth member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_unifiedDepth = "unifiedDepth";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_unifiedDepth;
            ann_custom_SampleConfig.reset();
            CompleteMemberDetail detail_unifiedDepth = TypeObjectUtils::build_complete_member_detail(name_unifiedDepth, member_ann_builtin_unifiedDepth, ann_custom_SampleConfig);
            CompleteStructMember member_unifiedDepth = TypeObjectUtils::build_complete_struct_member(common_unifiedDepth, detail_unifiedDepth);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleConfig, member_unifiedDepth);
        }
        {
            TypeIdentifierPair type_ids_sampleOrder;
            ReturnCode_t return_code_sampleOrder {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sampleOrder =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_sampleOrder);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sampleOrder)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "sampleOrder Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_sampleOrder = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sampleOrder = 0x00000001;
            bool common_sampleOrder_ec {false};
            CommonStructMember common_sampleOrder {TypeObjectUtils::build_common_struct_member(member_id_sampleOrder, member_flags_sampleOrder, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sampleOrder, common_sampleOrder_ec))};
            if (!common_sampleOrder_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sampleOrder member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sampleOrder = "sampleOrder";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sampleOrder;
            ann_custom_SampleConfig.reset();
            CompleteMemberDetail detail_sampleOrder = TypeObjectUtils::build_complete_member_detail(name_sampleOrder, member_ann_builtin_sampleOrder, ann_custom_SampleConfig);
            CompleteStructMember member_sampleOrder = TypeObjectUtils::build_complete_struct_member(common_sampleOrder, detail_sampleOrder);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleConfig, member_sampleOrder);
        }
        CompleteStructType struct_type_SampleConfig = TypeObjectUtils::build_complete_struct_type(struct_flags_SampleConfig, header_SampleConfig, member_seq_SampleConfig);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SampleConfig, type_name_SampleConfig.to_string(), type_ids_SampleConfig))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "SampleModule::SampleConfig already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_SampleCommand_type_identifier(
        TypeIdentifierPair& type_ids_SampleCommand)
{

    ReturnCode_t return_code_SampleCommand {eprosima::fastdds::dds::RETCODE_OK};
    return_code_SampleCommand =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::SampleCommand", type_ids_SampleCommand);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SampleCommand)
    {
        StructTypeFlag struct_flags_SampleCommand = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_SampleCommand = "SampleModule::SampleCommand";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SampleCommand;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SampleCommand;
        CompleteTypeDetail detail_SampleCommand = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SampleCommand, ann_custom_SampleCommand, type_name_SampleCommand.to_string());
        CompleteStructHeader header_SampleCommand;
        header_SampleCommand = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SampleCommand);
        CompleteStructMemberSeq member_seq_SampleCommand;
        {
            TypeIdentifierPair type_ids_maskBits;
            ReturnCode_t return_code_maskBits {eprosima::fastdds::dds::RETCODE_OK};
            return_code_maskBits =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_maskBits);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_maskBits)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "maskBits Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_maskBits = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_maskBits = 0x00000000;
            bool common_maskBits_ec {false};
            CommonStructMember common_maskBits {TypeObjectUtils::build_common_struct_member(member_id_maskBits, member_flags_maskBits, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_maskBits, common_maskBits_ec))};
            if (!common_maskBits_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure maskBits member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_maskBits = "maskBits";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_maskBits;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_maskBits = TypeObjectUtils::build_complete_member_detail(name_maskBits, member_ann_builtin_maskBits, ann_custom_SampleCommand);
            CompleteStructMember member_maskBits = TypeObjectUtils::build_complete_struct_member(common_maskBits, detail_maskBits);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_maskBits);
        }
        {
            TypeIdentifierPair type_ids_controlType;
            ReturnCode_t return_code_controlType {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlType =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_controlType);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlType)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "controlType Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_controlType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlType = 0x00000001;
            bool common_controlType_ec {false};
            CommonStructMember common_controlType {TypeObjectUtils::build_common_struct_member(member_id_controlType, member_flags_controlType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlType, common_controlType_ec))};
            if (!common_controlType_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlType member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlType = "controlType";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlType;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlType = TypeObjectUtils::build_complete_member_detail(name_controlType, member_ann_builtin_controlType, ann_custom_SampleCommand);
            CompleteStructMember member_controlType = TypeObjectUtils::build_complete_struct_member(common_controlType, detail_controlType);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlType);
        }
        {
            TypeIdentifierPair type_ids_startSample;
            ReturnCode_t return_code_startSample {eprosima::fastdds::dds::RETCODE_OK};
            return_code_startSample =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_startSample);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_startSample)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_startSample);
            }
            StructMemberFlag member_flags_startSample = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_startSample = 0x00000002;
            bool common_startSample_ec {false};
            CommonStructMember common_startSample {TypeObjectUtils::build_common_struct_member(member_id_startSample, member_flags_startSample, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_startSample, common_startSample_ec))};
            if (!common_startSample_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure startSample member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_startSample = "startSample";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_startSample;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_startSample = TypeObjectUtils::build_complete_member_detail(name_startSample, member_ann_builtin_startSample, ann_custom_SampleCommand);
            CompleteStructMember member_startSample = TypeObjectUtils::build_complete_struct_member(common_startSample, detail_startSample);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_startSample);
        }
        {
            TypeIdentifierPair type_ids_stopSample;
            ReturnCode_t return_code_stopSample {eprosima::fastdds::dds::RETCODE_OK};
            return_code_stopSample =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_stopSample);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_stopSample)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_stopSample);
            }
            StructMemberFlag member_flags_stopSample = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_stopSample = 0x00000003;
            bool common_stopSample_ec {false};
            CommonStructMember common_stopSample {TypeObjectUtils::build_common_struct_member(member_id_stopSample, member_flags_stopSample, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_stopSample, common_stopSample_ec))};
            if (!common_stopSample_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure stopSample member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_stopSample = "stopSample";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_stopSample;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_stopSample = TypeObjectUtils::build_complete_member_detail(name_stopSample, member_ann_builtin_stopSample, ann_custom_SampleCommand);
            CompleteStructMember member_stopSample = TypeObjectUtils::build_complete_struct_member(common_stopSample, detail_stopSample);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_stopSample);
        }
        {
            TypeIdentifierPair type_ids_reset;
            ReturnCode_t return_code_reset {eprosima::fastdds::dds::RETCODE_OK};
            return_code_reset =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_reset);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_reset)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_reset);
            }
            StructMemberFlag member_flags_reset = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_reset = 0x00000004;
            bool common_reset_ec {false};
            CommonStructMember common_reset {TypeObjectUtils::build_common_struct_member(member_id_reset, member_flags_reset, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_reset, common_reset_ec))};
            if (!common_reset_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure reset member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_reset = "reset";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_reset;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_reset = TypeObjectUtils::build_complete_member_detail(name_reset, member_ann_builtin_reset, ann_custom_SampleCommand);
            CompleteStructMember member_reset = TypeObjectUtils::build_complete_struct_member(common_reset, detail_reset);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_reset);
        }
        {
            TypeIdentifierPair type_ids_positionCheck;
            ReturnCode_t return_code_positionCheck {eprosima::fastdds::dds::RETCODE_OK};
            return_code_positionCheck =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_positionCheck);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_positionCheck)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_positionCheck);
            }
            StructMemberFlag member_flags_positionCheck = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_positionCheck = 0x00000005;
            bool common_positionCheck_ec {false};
            CommonStructMember common_positionCheck {TypeObjectUtils::build_common_struct_member(member_id_positionCheck, member_flags_positionCheck, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_positionCheck, common_positionCheck_ec))};
            if (!common_positionCheck_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure positionCheck member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_positionCheck = "positionCheck";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_positionCheck;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_positionCheck = TypeObjectUtils::build_complete_member_detail(name_positionCheck, member_ann_builtin_positionCheck, ann_custom_SampleCommand);
            CompleteStructMember member_positionCheck = TypeObjectUtils::build_complete_struct_member(common_positionCheck, detail_positionCheck);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_positionCheck);
        }
        {
            TypeIdentifierPair type_ids_emergencyUp;
            ReturnCode_t return_code_emergencyUp {eprosima::fastdds::dds::RETCODE_OK};
            return_code_emergencyUp =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_emergencyUp);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_emergencyUp)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_emergencyUp);
            }
            StructMemberFlag member_flags_emergencyUp = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_emergencyUp = 0x00000006;
            bool common_emergencyUp_ec {false};
            CommonStructMember common_emergencyUp {TypeObjectUtils::build_common_struct_member(member_id_emergencyUp, member_flags_emergencyUp, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_emergencyUp, common_emergencyUp_ec))};
            if (!common_emergencyUp_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure emergencyUp member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_emergencyUp = "emergencyUp";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_emergencyUp;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_emergencyUp = TypeObjectUtils::build_complete_member_detail(name_emergencyUp, member_ann_builtin_emergencyUp, ann_custom_SampleCommand);
            CompleteStructMember member_emergencyUp = TypeObjectUtils::build_complete_struct_member(common_emergencyUp, detail_emergencyUp);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_emergencyUp);
        }
        {
            TypeIdentifierPair type_ids_emergencyStop;
            ReturnCode_t return_code_emergencyStop {eprosima::fastdds::dds::RETCODE_OK};
            return_code_emergencyStop =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_emergencyStop);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_emergencyStop)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_emergencyStop);
            }
            StructMemberFlag member_flags_emergencyStop = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_emergencyStop = 0x00000007;
            bool common_emergencyStop_ec {false};
            CommonStructMember common_emergencyStop {TypeObjectUtils::build_common_struct_member(member_id_emergencyStop, member_flags_emergencyStop, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_emergencyStop, common_emergencyStop_ec))};
            if (!common_emergencyStop_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure emergencyStop member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_emergencyStop = "emergencyStop";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_emergencyStop;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_emergencyStop = TypeObjectUtils::build_complete_member_detail(name_emergencyStop, member_ann_builtin_emergencyStop, ann_custom_SampleCommand);
            CompleteStructMember member_emergencyStop = TypeObjectUtils::build_complete_struct_member(common_emergencyStop, detail_emergencyStop);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_emergencyStop);
        }
        {
            TypeIdentifierPair type_ids_controlBelt1;
            ReturnCode_t return_code_controlBelt1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlBelt1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlBelt1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlBelt1)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlBelt1);
            }
            StructMemberFlag member_flags_controlBelt1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlBelt1 = 0x00000008;
            bool common_controlBelt1_ec {false};
            CommonStructMember common_controlBelt1 {TypeObjectUtils::build_common_struct_member(member_id_controlBelt1, member_flags_controlBelt1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlBelt1, common_controlBelt1_ec))};
            if (!common_controlBelt1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlBelt1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlBelt1 = "controlBelt1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlBelt1;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlBelt1 = TypeObjectUtils::build_complete_member_detail(name_controlBelt1, member_ann_builtin_controlBelt1, ann_custom_SampleCommand);
            CompleteStructMember member_controlBelt1 = TypeObjectUtils::build_complete_struct_member(common_controlBelt1, detail_controlBelt1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlBelt1);
        }
        {
            TypeIdentifierPair type_ids_controlBelt2;
            ReturnCode_t return_code_controlBelt2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlBelt2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlBelt2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlBelt2)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlBelt2);
            }
            StructMemberFlag member_flags_controlBelt2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlBelt2 = 0x00000009;
            bool common_controlBelt2_ec {false};
            CommonStructMember common_controlBelt2 {TypeObjectUtils::build_common_struct_member(member_id_controlBelt2, member_flags_controlBelt2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlBelt2, common_controlBelt2_ec))};
            if (!common_controlBelt2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlBelt2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlBelt2 = "controlBelt2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlBelt2;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlBelt2 = TypeObjectUtils::build_complete_member_detail(name_controlBelt2, member_ann_builtin_controlBelt2, ann_custom_SampleCommand);
            CompleteStructMember member_controlBelt2 = TypeObjectUtils::build_complete_struct_member(common_controlBelt2, detail_controlBelt2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlBelt2);
        }
        {
            TypeIdentifierPair type_ids_controlCrush1;
            ReturnCode_t return_code_controlCrush1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlCrush1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlCrush1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlCrush1)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlCrush1);
            }
            StructMemberFlag member_flags_controlCrush1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlCrush1 = 0x0000000a;
            bool common_controlCrush1_ec {false};
            CommonStructMember common_controlCrush1 {TypeObjectUtils::build_common_struct_member(member_id_controlCrush1, member_flags_controlCrush1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlCrush1, common_controlCrush1_ec))};
            if (!common_controlCrush1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlCrush1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlCrush1 = "controlCrush1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlCrush1;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlCrush1 = TypeObjectUtils::build_complete_member_detail(name_controlCrush1, member_ann_builtin_controlCrush1, ann_custom_SampleCommand);
            CompleteStructMember member_controlCrush1 = TypeObjectUtils::build_complete_struct_member(common_controlCrush1, detail_controlCrush1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlCrush1);
        }
        {
            TypeIdentifierPair type_ids_controlCrush2;
            ReturnCode_t return_code_controlCrush2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlCrush2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlCrush2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlCrush2)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlCrush2);
            }
            StructMemberFlag member_flags_controlCrush2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlCrush2 = 0x0000000b;
            bool common_controlCrush2_ec {false};
            CommonStructMember common_controlCrush2 {TypeObjectUtils::build_common_struct_member(member_id_controlCrush2, member_flags_controlCrush2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlCrush2, common_controlCrush2_ec))};
            if (!common_controlCrush2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlCrush2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlCrush2 = "controlCrush2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlCrush2;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlCrush2 = TypeObjectUtils::build_complete_member_detail(name_controlCrush2, member_ann_builtin_controlCrush2, ann_custom_SampleCommand);
            CompleteStructMember member_controlCrush2 = TypeObjectUtils::build_complete_struct_member(common_controlCrush2, detail_controlCrush2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlCrush2);
        }
        {
            TypeIdentifierPair type_ids_controlDivider;
            ReturnCode_t return_code_controlDivider {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlDivider =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlDivider);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlDivider)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlDivider);
            }
            StructMemberFlag member_flags_controlDivider = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlDivider = 0x0000000c;
            bool common_controlDivider_ec {false};
            CommonStructMember common_controlDivider {TypeObjectUtils::build_common_struct_member(member_id_controlDivider, member_flags_controlDivider, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlDivider, common_controlDivider_ec))};
            if (!common_controlDivider_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlDivider member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlDivider = "controlDivider";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlDivider;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlDivider = TypeObjectUtils::build_complete_member_detail(name_controlDivider, member_ann_builtin_controlDivider, ann_custom_SampleCommand);
            CompleteStructMember member_controlDivider = TypeObjectUtils::build_complete_struct_member(common_controlDivider, detail_controlDivider);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlDivider);
        }
        {
            TypeIdentifierPair type_ids_controlCoalDistributor;
            ReturnCode_t return_code_controlCoalDistributor {eprosima::fastdds::dds::RETCODE_OK};
            return_code_controlCoalDistributor =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::CommandState", type_ids_controlCoalDistributor);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_controlCoalDistributor)
            {
                SampleModule::register_CommandState_type_identifier(type_ids_controlCoalDistributor);
            }
            StructMemberFlag member_flags_controlCoalDistributor = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_controlCoalDistributor = 0x0000000d;
            bool common_controlCoalDistributor_ec {false};
            CommonStructMember common_controlCoalDistributor {TypeObjectUtils::build_common_struct_member(member_id_controlCoalDistributor, member_flags_controlCoalDistributor, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_controlCoalDistributor, common_controlCoalDistributor_ec))};
            if (!common_controlCoalDistributor_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure controlCoalDistributor member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_controlCoalDistributor = "controlCoalDistributor";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_controlCoalDistributor;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_controlCoalDistributor = TypeObjectUtils::build_complete_member_detail(name_controlCoalDistributor, member_ann_builtin_controlCoalDistributor, ann_custom_SampleCommand);
            CompleteStructMember member_controlCoalDistributor = TypeObjectUtils::build_complete_struct_member(common_controlCoalDistributor, detail_controlCoalDistributor);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_controlCoalDistributor);
        }
        {
            TypeIdentifierPair type_ids_reductionRatio;
            ReturnCode_t return_code_reductionRatio {eprosima::fastdds::dds::RETCODE_OK};
            return_code_reductionRatio =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_reductionRatio);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_reductionRatio)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "reductionRatio Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_reductionRatio = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_reductionRatio = 0x0000000e;
            bool common_reductionRatio_ec {false};
            CommonStructMember common_reductionRatio {TypeObjectUtils::build_common_struct_member(member_id_reductionRatio, member_flags_reductionRatio, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_reductionRatio, common_reductionRatio_ec))};
            if (!common_reductionRatio_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure reductionRatio member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_reductionRatio = "reductionRatio";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_reductionRatio;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_reductionRatio = TypeObjectUtils::build_complete_member_detail(name_reductionRatio, member_ann_builtin_reductionRatio, ann_custom_SampleCommand);
            CompleteStructMember member_reductionRatio = TypeObjectUtils::build_complete_struct_member(common_reductionRatio, detail_reductionRatio);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_reductionRatio);
        }
        {
            TypeIdentifierPair type_ids_version;
            ReturnCode_t return_code_version {eprosima::fastdds::dds::RETCODE_OK};
            return_code_version =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_version);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_version)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "version Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_version = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_version = 0x0000000f;
            bool common_version_ec {false};
            CommonStructMember common_version {TypeObjectUtils::build_common_struct_member(member_id_version, member_flags_version, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_version, common_version_ec))};
            if (!common_version_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure version member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_version = "version";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_version;
            ann_custom_SampleCommand.reset();
            CompleteMemberDetail detail_version = TypeObjectUtils::build_complete_member_detail(name_version, member_ann_builtin_version, ann_custom_SampleCommand);
            CompleteStructMember member_version = TypeObjectUtils::build_complete_struct_member(common_version, detail_version);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleCommand, member_version);
        }
        CompleteStructType struct_type_SampleCommand = TypeObjectUtils::build_complete_struct_type(struct_flags_SampleCommand, header_SampleCommand, member_seq_SampleCommand);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SampleCommand, type_name_SampleCommand.to_string(), type_ids_SampleCommand))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "SampleModule::SampleCommand already registered in TypeObjectRegistry for a different type.");
        }
    }
}
void register_DeviceState_type_identifier(
        TypeIdentifierPair& type_ids_DeviceState)
{
    ReturnCode_t return_code_DeviceState {eprosima::fastdds::dds::RETCODE_OK};
    return_code_DeviceState =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::DeviceState", type_ids_DeviceState);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_DeviceState)
    {
        EnumTypeFlag enum_flags_DeviceState = 0;
        BitBound bit_bound_DeviceState = 32;
        CommonEnumeratedHeader common_DeviceState = TypeObjectUtils::build_common_enumerated_header(bit_bound_DeviceState);
        QualifiedTypeName type_name_DeviceState = "SampleModule::DeviceState";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_DeviceState;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_DeviceState;
        CompleteTypeDetail detail_DeviceState = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_DeviceState, ann_custom_DeviceState, type_name_DeviceState.to_string());
        CompleteEnumeratedHeader header_DeviceState = TypeObjectUtils::build_complete_enumerated_header(common_DeviceState, detail_DeviceState);
        CompleteEnumeratedLiteralSeq literal_seq_DeviceState;
        {
            EnumeratedLiteralFlag flags_OFF = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_OFF = TypeObjectUtils::build_common_enumerated_literal(0, flags_OFF);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_OFF;
            ann_custom_DeviceState.reset();
            MemberName name_OFF = "OFF";
            CompleteMemberDetail detail_OFF = TypeObjectUtils::build_complete_member_detail(name_OFF, member_ann_builtin_OFF, ann_custom_DeviceState);
            CompleteEnumeratedLiteral literal_OFF = TypeObjectUtils::build_complete_enumerated_literal(common_OFF, detail_OFF);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_DeviceState, literal_OFF);
        }
        {
            EnumeratedLiteralFlag flags_ON = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_ON = TypeObjectUtils::build_common_enumerated_literal(1, flags_ON);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ON;
            ann_custom_DeviceState.reset();
            MemberName name_ON = "ON";
            CompleteMemberDetail detail_ON = TypeObjectUtils::build_complete_member_detail(name_ON, member_ann_builtin_ON, ann_custom_DeviceState);
            CompleteEnumeratedLiteral literal_ON = TypeObjectUtils::build_complete_enumerated_literal(common_ON, detail_ON);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_DeviceState, literal_ON);
        }
        {
            EnumeratedLiteralFlag flags_ERROR = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_ERROR = TypeObjectUtils::build_common_enumerated_literal(2, flags_ERROR);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ERROR;
            ann_custom_DeviceState.reset();
            MemberName name_ERROR = "ERROR";
            CompleteMemberDetail detail_ERROR = TypeObjectUtils::build_complete_member_detail(name_ERROR, member_ann_builtin_ERROR, ann_custom_DeviceState);
            CompleteEnumeratedLiteral literal_ERROR = TypeObjectUtils::build_complete_enumerated_literal(common_ERROR, detail_ERROR);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_DeviceState, literal_ERROR);
        }
        CompleteEnumeratedType enumerated_type_DeviceState = TypeObjectUtils::build_complete_enumerated_type(enum_flags_DeviceState, header_DeviceState,
                literal_seq_DeviceState);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_enumerated_type_object(enumerated_type_DeviceState, type_name_DeviceState.to_string(), type_ids_DeviceState))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                "SampleModule::DeviceState already registered in TypeObjectRegistry for a different type.");
        }
    }
}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_SampleMachineInfo_type_identifier(
        TypeIdentifierPair& type_ids_SampleMachineInfo)
{

    ReturnCode_t return_code_SampleMachineInfo {eprosima::fastdds::dds::RETCODE_OK};
    return_code_SampleMachineInfo =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::SampleMachineInfo", type_ids_SampleMachineInfo);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SampleMachineInfo)
    {
        StructTypeFlag struct_flags_SampleMachineInfo = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_SampleMachineInfo = "SampleModule::SampleMachineInfo";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SampleMachineInfo;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SampleMachineInfo;
        CompleteTypeDetail detail_SampleMachineInfo = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SampleMachineInfo, ann_custom_SampleMachineInfo, type_name_SampleMachineInfo.to_string());
        CompleteStructHeader header_SampleMachineInfo;
        header_SampleMachineInfo = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SampleMachineInfo);
        CompleteStructMemberSeq member_seq_SampleMachineInfo;
        {
            TypeIdentifierPair type_ids_maskBits;
            ReturnCode_t return_code_maskBits {eprosima::fastdds::dds::RETCODE_OK};
            return_code_maskBits =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_maskBits);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_maskBits)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "maskBits Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_maskBits = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_maskBits = 0x00000000;
            bool common_maskBits_ec {false};
            CommonStructMember common_maskBits {TypeObjectUtils::build_common_struct_member(member_id_maskBits, member_flags_maskBits, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_maskBits, common_maskBits_ec))};
            if (!common_maskBits_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure maskBits member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_maskBits = "maskBits";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_maskBits;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_maskBits = TypeObjectUtils::build_complete_member_detail(name_maskBits, member_ann_builtin_maskBits, ann_custom_SampleMachineInfo);
            CompleteStructMember member_maskBits = TypeObjectUtils::build_complete_struct_member(common_maskBits, detail_maskBits);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_maskBits);
        }
        {
            TypeIdentifierPair type_ids_bigPoint;
            ReturnCode_t return_code_bigPoint {eprosima::fastdds::dds::RETCODE_OK};
            return_code_bigPoint =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_bigPoint);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_bigPoint)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "bigPoint Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_bigPoint = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_bigPoint = 0x00000001;
            bool common_bigPoint_ec {false};
            CommonStructMember common_bigPoint {TypeObjectUtils::build_common_struct_member(member_id_bigPoint, member_flags_bigPoint, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bigPoint, common_bigPoint_ec))};
            if (!common_bigPoint_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure bigPoint member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_bigPoint = "bigPoint";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_bigPoint;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_bigPoint = TypeObjectUtils::build_complete_member_detail(name_bigPoint, member_ann_builtin_bigPoint, ann_custom_SampleMachineInfo);
            CompleteStructMember member_bigPoint = TypeObjectUtils::build_complete_struct_member(common_bigPoint, detail_bigPoint);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_bigPoint);
        }
        {
            TypeIdentifierPair type_ids_smallPoint;
            ReturnCode_t return_code_smallPoint {eprosima::fastdds::dds::RETCODE_OK};
            return_code_smallPoint =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_smallPoint);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_smallPoint)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "smallPoint Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_smallPoint = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_smallPoint = 0x00000002;
            bool common_smallPoint_ec {false};
            CommonStructMember common_smallPoint {TypeObjectUtils::build_common_struct_member(member_id_smallPoint, member_flags_smallPoint, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_smallPoint, common_smallPoint_ec))};
            if (!common_smallPoint_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure smallPoint member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_smallPoint = "smallPoint";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_smallPoint;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_smallPoint = TypeObjectUtils::build_complete_member_detail(name_smallPoint, member_ann_builtin_smallPoint, ann_custom_SampleMachineInfo);
            CompleteStructMember member_smallPoint = TypeObjectUtils::build_complete_struct_member(common_smallPoint, detail_smallPoint);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_smallPoint);
        }
        {
            TypeIdentifierPair type_ids_depthPoint;
            ReturnCode_t return_code_depthPoint {eprosima::fastdds::dds::RETCODE_OK};
            return_code_depthPoint =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_depthPoint);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_depthPoint)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "depthPoint Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_depthPoint = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_depthPoint = 0x00000003;
            bool common_depthPoint_ec {false};
            CommonStructMember common_depthPoint {TypeObjectUtils::build_common_struct_member(member_id_depthPoint, member_flags_depthPoint, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_depthPoint, common_depthPoint_ec))};
            if (!common_depthPoint_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure depthPoint member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_depthPoint = "depthPoint";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_depthPoint;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_depthPoint = TypeObjectUtils::build_complete_member_detail(name_depthPoint, member_ann_builtin_depthPoint, ann_custom_SampleMachineInfo);
            CompleteStructMember member_depthPoint = TypeObjectUtils::build_complete_struct_member(common_depthPoint, detail_depthPoint);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_depthPoint);
        }
        {
            TypeIdentifierPair type_ids_hasToXY;
            ReturnCode_t return_code_hasToXY {eprosima::fastdds::dds::RETCODE_OK};
            return_code_hasToXY =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_hasToXY);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_hasToXY)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "hasToXY Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_hasToXY = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_hasToXY = 0x00000004;
            bool common_hasToXY_ec {false};
            CommonStructMember common_hasToXY {TypeObjectUtils::build_common_struct_member(member_id_hasToXY, member_flags_hasToXY, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_hasToXY, common_hasToXY_ec))};
            if (!common_hasToXY_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure hasToXY member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_hasToXY = "hasToXY";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_hasToXY;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_hasToXY = TypeObjectUtils::build_complete_member_detail(name_hasToXY, member_ann_builtin_hasToXY, ann_custom_SampleMachineInfo);
            CompleteStructMember member_hasToXY = TypeObjectUtils::build_complete_struct_member(common_hasToXY, detail_hasToXY);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_hasToXY);
        }
        {
            TypeIdentifierPair type_ids_hasSamplePoints;
            ReturnCode_t return_code_hasSamplePoints {eprosima::fastdds::dds::RETCODE_OK};
            return_code_hasSamplePoints =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_hasSamplePoints);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_hasSamplePoints)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "hasSamplePoints Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_hasSamplePoints = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_hasSamplePoints = 0x00000005;
            bool common_hasSamplePoints_ec {false};
            CommonStructMember common_hasSamplePoints {TypeObjectUtils::build_common_struct_member(member_id_hasSamplePoints, member_flags_hasSamplePoints, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_hasSamplePoints, common_hasSamplePoints_ec))};
            if (!common_hasSamplePoints_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure hasSamplePoints member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_hasSamplePoints = "hasSamplePoints";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_hasSamplePoints;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_hasSamplePoints = TypeObjectUtils::build_complete_member_detail(name_hasSamplePoints, member_ann_builtin_hasSamplePoints, ann_custom_SampleMachineInfo);
            CompleteStructMember member_hasSamplePoints = TypeObjectUtils::build_complete_struct_member(common_hasSamplePoints, detail_hasSamplePoints);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_hasSamplePoints);
        }
        {
            TypeIdentifierPair type_ids_gameOver;
            ReturnCode_t return_code_gameOver {eprosima::fastdds::dds::RETCODE_OK};
            return_code_gameOver =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_gameOver);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_gameOver)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "gameOver Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_gameOver = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_gameOver = 0x00000006;
            bool common_gameOver_ec {false};
            CommonStructMember common_gameOver {TypeObjectUtils::build_common_struct_member(member_id_gameOver, member_flags_gameOver, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_gameOver, common_gameOver_ec))};
            if (!common_gameOver_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure gameOver member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_gameOver = "gameOver";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_gameOver;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_gameOver = TypeObjectUtils::build_complete_member_detail(name_gameOver, member_ann_builtin_gameOver, ann_custom_SampleMachineInfo);
            CompleteStructMember member_gameOver = TypeObjectUtils::build_complete_struct_member(common_gameOver, detail_gameOver);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_gameOver);
        }
        {
            TypeIdentifierPair type_ids_backState;
            ReturnCode_t return_code_backState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_backState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_backState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_backState)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "backState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_backState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_backState = 0x00000007;
            bool common_backState_ec {false};
            CommonStructMember common_backState {TypeObjectUtils::build_common_struct_member(member_id_backState, member_flags_backState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_backState, common_backState_ec))};
            if (!common_backState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure backState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_backState = "backState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_backState;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_backState = TypeObjectUtils::build_complete_member_detail(name_backState, member_ann_builtin_backState, ann_custom_SampleMachineInfo);
            CompleteStructMember member_backState = TypeObjectUtils::build_complete_struct_member(common_backState, detail_backState);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_backState);
        }
        {
            TypeIdentifierPair type_ids_sampleState;
            ReturnCode_t return_code_sampleState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sampleState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_sampleState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sampleState)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_sampleState);
            }
            StructMemberFlag member_flags_sampleState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sampleState = 0x00000008;
            bool common_sampleState_ec {false};
            CommonStructMember common_sampleState {TypeObjectUtils::build_common_struct_member(member_id_sampleState, member_flags_sampleState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sampleState, common_sampleState_ec))};
            if (!common_sampleState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sampleState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sampleState = "sampleState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sampleState;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_sampleState = TypeObjectUtils::build_complete_member_detail(name_sampleState, member_ann_builtin_sampleState, ann_custom_SampleMachineInfo);
            CompleteStructMember member_sampleState = TypeObjectUtils::build_complete_struct_member(common_sampleState, detail_sampleState);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_sampleState);
        }
        {
            TypeIdentifierPair type_ids_belt1State;
            ReturnCode_t return_code_belt1State {eprosima::fastdds::dds::RETCODE_OK};
            return_code_belt1State =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_belt1State);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_belt1State)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_belt1State);
            }
            StructMemberFlag member_flags_belt1State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_belt1State = 0x00000009;
            bool common_belt1State_ec {false};
            CommonStructMember common_belt1State {TypeObjectUtils::build_common_struct_member(member_id_belt1State, member_flags_belt1State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_belt1State, common_belt1State_ec))};
            if (!common_belt1State_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure belt1State member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_belt1State = "belt1State";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_belt1State;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_belt1State = TypeObjectUtils::build_complete_member_detail(name_belt1State, member_ann_builtin_belt1State, ann_custom_SampleMachineInfo);
            CompleteStructMember member_belt1State = TypeObjectUtils::build_complete_struct_member(common_belt1State, detail_belt1State);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_belt1State);
        }
        {
            TypeIdentifierPair type_ids_belt2State;
            ReturnCode_t return_code_belt2State {eprosima::fastdds::dds::RETCODE_OK};
            return_code_belt2State =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_belt2State);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_belt2State)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_belt2State);
            }
            StructMemberFlag member_flags_belt2State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_belt2State = 0x0000000a;
            bool common_belt2State_ec {false};
            CommonStructMember common_belt2State {TypeObjectUtils::build_common_struct_member(member_id_belt2State, member_flags_belt2State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_belt2State, common_belt2State_ec))};
            if (!common_belt2State_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure belt2State member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_belt2State = "belt2State";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_belt2State;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_belt2State = TypeObjectUtils::build_complete_member_detail(name_belt2State, member_ann_builtin_belt2State, ann_custom_SampleMachineInfo);
            CompleteStructMember member_belt2State = TypeObjectUtils::build_complete_struct_member(common_belt2State, detail_belt2State);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_belt2State);
        }
        {
            TypeIdentifierPair type_ids_crush1State;
            ReturnCode_t return_code_crush1State {eprosima::fastdds::dds::RETCODE_OK};
            return_code_crush1State =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_crush1State);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_crush1State)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_crush1State);
            }
            StructMemberFlag member_flags_crush1State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_crush1State = 0x0000000b;
            bool common_crush1State_ec {false};
            CommonStructMember common_crush1State {TypeObjectUtils::build_common_struct_member(member_id_crush1State, member_flags_crush1State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_crush1State, common_crush1State_ec))};
            if (!common_crush1State_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure crush1State member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_crush1State = "crush1State";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_crush1State;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_crush1State = TypeObjectUtils::build_complete_member_detail(name_crush1State, member_ann_builtin_crush1State, ann_custom_SampleMachineInfo);
            CompleteStructMember member_crush1State = TypeObjectUtils::build_complete_struct_member(common_crush1State, detail_crush1State);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_crush1State);
        }
        {
            TypeIdentifierPair type_ids_crush2State;
            ReturnCode_t return_code_crush2State {eprosima::fastdds::dds::RETCODE_OK};
            return_code_crush2State =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_crush2State);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_crush2State)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_crush2State);
            }
            StructMemberFlag member_flags_crush2State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_crush2State = 0x0000000c;
            bool common_crush2State_ec {false};
            CommonStructMember common_crush2State {TypeObjectUtils::build_common_struct_member(member_id_crush2State, member_flags_crush2State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_crush2State, common_crush2State_ec))};
            if (!common_crush2State_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure crush2State member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_crush2State = "crush2State";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_crush2State;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_crush2State = TypeObjectUtils::build_complete_member_detail(name_crush2State, member_ann_builtin_crush2State, ann_custom_SampleMachineInfo);
            CompleteStructMember member_crush2State = TypeObjectUtils::build_complete_struct_member(common_crush2State, detail_crush2State);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_crush2State);
        }
        {
            TypeIdentifierPair type_ids_dividerState;
            ReturnCode_t return_code_dividerState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_dividerState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DeviceState", type_ids_dividerState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_dividerState)
            {
                SampleModule::register_DeviceState_type_identifier(type_ids_dividerState);
            }
            StructMemberFlag member_flags_dividerState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_dividerState = 0x0000000d;
            bool common_dividerState_ec {false};
            CommonStructMember common_dividerState {TypeObjectUtils::build_common_struct_member(member_id_dividerState, member_flags_dividerState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_dividerState, common_dividerState_ec))};
            if (!common_dividerState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure dividerState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_dividerState = "dividerState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_dividerState;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_dividerState = TypeObjectUtils::build_complete_member_detail(name_dividerState, member_ann_builtin_dividerState, ann_custom_SampleMachineInfo);
            CompleteStructMember member_dividerState = TypeObjectUtils::build_complete_struct_member(common_dividerState, detail_dividerState);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_dividerState);
        }
        {
            TypeIdentifierPair type_ids_bigLimit;
            ReturnCode_t return_code_bigLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_bigLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_bigLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_bigLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "bigLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_bigLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_bigLimit = 0x0000000e;
            bool common_bigLimit_ec {false};
            CommonStructMember common_bigLimit {TypeObjectUtils::build_common_struct_member(member_id_bigLimit, member_flags_bigLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bigLimit, common_bigLimit_ec))};
            if (!common_bigLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure bigLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_bigLimit = "bigLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_bigLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_bigLimit = TypeObjectUtils::build_complete_member_detail(name_bigLimit, member_ann_builtin_bigLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_bigLimit = TypeObjectUtils::build_complete_struct_member(common_bigLimit, detail_bigLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_bigLimit);
        }
        {
            TypeIdentifierPair type_ids_bigZeroLimit;
            ReturnCode_t return_code_bigZeroLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_bigZeroLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_bigZeroLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_bigZeroLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "bigZeroLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_bigZeroLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_bigZeroLimit = 0x0000000f;
            bool common_bigZeroLimit_ec {false};
            CommonStructMember common_bigZeroLimit {TypeObjectUtils::build_common_struct_member(member_id_bigZeroLimit, member_flags_bigZeroLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_bigZeroLimit, common_bigZeroLimit_ec))};
            if (!common_bigZeroLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure bigZeroLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_bigZeroLimit = "bigZeroLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_bigZeroLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_bigZeroLimit = TypeObjectUtils::build_complete_member_detail(name_bigZeroLimit, member_ann_builtin_bigZeroLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_bigZeroLimit = TypeObjectUtils::build_complete_struct_member(common_bigZeroLimit, detail_bigZeroLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_bigZeroLimit);
        }
        {
            TypeIdentifierPair type_ids_smallLimit;
            ReturnCode_t return_code_smallLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_smallLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_smallLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_smallLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "smallLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_smallLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_smallLimit = 0x00000010;
            bool common_smallLimit_ec {false};
            CommonStructMember common_smallLimit {TypeObjectUtils::build_common_struct_member(member_id_smallLimit, member_flags_smallLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_smallLimit, common_smallLimit_ec))};
            if (!common_smallLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure smallLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_smallLimit = "smallLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_smallLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_smallLimit = TypeObjectUtils::build_complete_member_detail(name_smallLimit, member_ann_builtin_smallLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_smallLimit = TypeObjectUtils::build_complete_struct_member(common_smallLimit, detail_smallLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_smallLimit);
        }
        {
            TypeIdentifierPair type_ids_smallZeroLimit;
            ReturnCode_t return_code_smallZeroLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_smallZeroLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_smallZeroLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_smallZeroLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "smallZeroLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_smallZeroLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_smallZeroLimit = 0x00000011;
            bool common_smallZeroLimit_ec {false};
            CommonStructMember common_smallZeroLimit {TypeObjectUtils::build_common_struct_member(member_id_smallZeroLimit, member_flags_smallZeroLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_smallZeroLimit, common_smallZeroLimit_ec))};
            if (!common_smallZeroLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure smallZeroLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_smallZeroLimit = "smallZeroLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_smallZeroLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_smallZeroLimit = TypeObjectUtils::build_complete_member_detail(name_smallZeroLimit, member_ann_builtin_smallZeroLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_smallZeroLimit = TypeObjectUtils::build_complete_struct_member(common_smallZeroLimit, detail_smallZeroLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_smallZeroLimit);
        }
        {
            TypeIdentifierPair type_ids_upLimit;
            ReturnCode_t return_code_upLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_upLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_upLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_upLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "upLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_upLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_upLimit = 0x00000012;
            bool common_upLimit_ec {false};
            CommonStructMember common_upLimit {TypeObjectUtils::build_common_struct_member(member_id_upLimit, member_flags_upLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_upLimit, common_upLimit_ec))};
            if (!common_upLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure upLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_upLimit = "upLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_upLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_upLimit = TypeObjectUtils::build_complete_member_detail(name_upLimit, member_ann_builtin_upLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_upLimit = TypeObjectUtils::build_complete_struct_member(common_upLimit, detail_upLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_upLimit);
        }
        {
            TypeIdentifierPair type_ids_downLimit;
            ReturnCode_t return_code_downLimit {eprosima::fastdds::dds::RETCODE_OK};
            return_code_downLimit =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_downLimit);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_downLimit)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "downLimit Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_downLimit = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_downLimit = 0x00000013;
            bool common_downLimit_ec {false};
            CommonStructMember common_downLimit {TypeObjectUtils::build_common_struct_member(member_id_downLimit, member_flags_downLimit, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_downLimit, common_downLimit_ec))};
            if (!common_downLimit_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure downLimit member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_downLimit = "downLimit";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_downLimit;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_downLimit = TypeObjectUtils::build_complete_member_detail(name_downLimit, member_ann_builtin_downLimit, ann_custom_SampleMachineInfo);
            CompleteStructMember member_downLimit = TypeObjectUtils::build_complete_struct_member(common_downLimit, detail_downLimit);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_downLimit);
        }
        {
            TypeIdentifierPair type_ids_version;
            ReturnCode_t return_code_version {eprosima::fastdds::dds::RETCODE_OK};
            return_code_version =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_version);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_version)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "version Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_version = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_version = 0x00000014;
            bool common_version_ec {false};
            CommonStructMember common_version {TypeObjectUtils::build_common_struct_member(member_id_version, member_flags_version, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_version, common_version_ec))};
            if (!common_version_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure version member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_version = "version";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_version;
            ann_custom_SampleMachineInfo.reset();
            CompleteMemberDetail detail_version = TypeObjectUtils::build_complete_member_detail(name_version, member_ann_builtin_version, ann_custom_SampleMachineInfo);
            CompleteStructMember member_version = TypeObjectUtils::build_complete_struct_member(common_version, detail_version);
            TypeObjectUtils::add_complete_struct_member(member_seq_SampleMachineInfo, member_version);
        }
        CompleteStructType struct_type_SampleMachineInfo = TypeObjectUtils::build_complete_struct_type(struct_flags_SampleMachineInfo, header_SampleMachineInfo, member_seq_SampleMachineInfo);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SampleMachineInfo, type_name_SampleMachineInfo.to_string(), type_ids_SampleMachineInfo))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "SampleModule::SampleMachineInfo already registered in TypeObjectRegistry for a different type.");
        }
    }
}
void register_DropChoice_type_identifier(
        TypeIdentifierPair& type_ids_DropChoice)
{
    ReturnCode_t return_code_DropChoice {eprosima::fastdds::dds::RETCODE_OK};
    return_code_DropChoice =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::DropChoice", type_ids_DropChoice);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_DropChoice)
    {
        EnumTypeFlag enum_flags_DropChoice = 0;
        BitBound bit_bound_DropChoice = 32;
        CommonEnumeratedHeader common_DropChoice = TypeObjectUtils::build_common_enumerated_header(bit_bound_DropChoice);
        QualifiedTypeName type_name_DropChoice = "SampleModule::DropChoice";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_DropChoice;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_DropChoice;
        CompleteTypeDetail detail_DropChoice = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_DropChoice, ann_custom_DropChoice, type_name_DropChoice.to_string());
        CompleteEnumeratedHeader header_DropChoice = TypeObjectUtils::build_complete_enumerated_header(common_DropChoice, detail_DropChoice);
        CompleteEnumeratedLiteralSeq literal_seq_DropChoice;
        {
            EnumeratedLiteralFlag flags_BYPASS = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_BYPASS = TypeObjectUtils::build_common_enumerated_literal(0, flags_BYPASS);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BYPASS;
            ann_custom_DropChoice.reset();
            MemberName name_BYPASS = "BYPASS";
            CompleteMemberDetail detail_BYPASS = TypeObjectUtils::build_complete_member_detail(name_BYPASS, member_ann_builtin_BYPASS, ann_custom_DropChoice);
            CompleteEnumeratedLiteral literal_BYPASS = TypeObjectUtils::build_complete_enumerated_literal(common_BYPASS, detail_BYPASS);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_DropChoice, literal_BYPASS);
        }
        {
            EnumeratedLiteralFlag flags_CRUSHER = TypeObjectUtils::build_enumerated_literal_flag(false);
            CommonEnumeratedLiteral common_CRUSHER = TypeObjectUtils::build_common_enumerated_literal(1, flags_CRUSHER);
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_CRUSHER;
            ann_custom_DropChoice.reset();
            MemberName name_CRUSHER = "CRUSHER";
            CompleteMemberDetail detail_CRUSHER = TypeObjectUtils::build_complete_member_detail(name_CRUSHER, member_ann_builtin_CRUSHER, ann_custom_DropChoice);
            CompleteEnumeratedLiteral literal_CRUSHER = TypeObjectUtils::build_complete_enumerated_literal(common_CRUSHER, detail_CRUSHER);
            TypeObjectUtils::add_complete_enumerated_literal(literal_seq_DropChoice, literal_CRUSHER);
        }
        CompleteEnumeratedType enumerated_type_DropChoice = TypeObjectUtils::build_complete_enumerated_type(enum_flags_DropChoice, header_DropChoice,
                literal_seq_DropChoice);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_enumerated_type_object(enumerated_type_DropChoice, type_name_DropChoice.to_string(), type_ids_DropChoice))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                "SampleModule::DropChoice already registered in TypeObjectRegistry for a different type.");
        }
    }
}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_SamplePoints_type_identifier(
        TypeIdentifierPair& type_ids_SamplePoints)
{

    ReturnCode_t return_code_SamplePoints {eprosima::fastdds::dds::RETCODE_OK};
    return_code_SamplePoints =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "SampleModule::SamplePoints", type_ids_SamplePoints);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SamplePoints)
    {
        StructTypeFlag struct_flags_SamplePoints = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_SamplePoints = "SampleModule::SamplePoints";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SamplePoints;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SamplePoints;
        CompleteTypeDetail detail_SamplePoints = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SamplePoints, ann_custom_SamplePoints, type_name_SamplePoints.to_string());
        CompleteStructHeader header_SamplePoints;
        header_SamplePoints = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SamplePoints);
        CompleteStructMemberSeq member_seq_SamplePoints;
        {
            TypeIdentifierPair type_ids_totalPoints;
            ReturnCode_t return_code_totalPoints {eprosima::fastdds::dds::RETCODE_OK};
            return_code_totalPoints =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint8_t", type_ids_totalPoints);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_totalPoints)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "totalPoints Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_totalPoints = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_totalPoints = 0x00000000;
            bool common_totalPoints_ec {false};
            CommonStructMember common_totalPoints {TypeObjectUtils::build_common_struct_member(member_id_totalPoints, member_flags_totalPoints, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_totalPoints, common_totalPoints_ec))};
            if (!common_totalPoints_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure totalPoints member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_totalPoints = "totalPoints";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_totalPoints;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_totalPoints = TypeObjectUtils::build_complete_member_detail(name_totalPoints, member_ann_builtin_totalPoints, ann_custom_SamplePoints);
            CompleteStructMember member_totalPoints = TypeObjectUtils::build_complete_struct_member(common_totalPoints, detail_totalPoints);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_totalPoints);
        }
        {
            TypeIdentifierPair type_ids_x1;
            ReturnCode_t return_code_x1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x1)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x1 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x1 = 0x00000001;
            bool common_x1_ec {false};
            CommonStructMember common_x1 {TypeObjectUtils::build_common_struct_member(member_id_x1, member_flags_x1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x1, common_x1_ec))};
            if (!common_x1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x1 = "x1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x1;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x1 = TypeObjectUtils::build_complete_member_detail(name_x1, member_ann_builtin_x1, ann_custom_SamplePoints);
            CompleteStructMember member_x1 = TypeObjectUtils::build_complete_struct_member(common_x1, detail_x1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x1);
        }
        {
            TypeIdentifierPair type_ids_y1;
            ReturnCode_t return_code_y1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y1)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y1 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y1 = 0x00000002;
            bool common_y1_ec {false};
            CommonStructMember common_y1 {TypeObjectUtils::build_common_struct_member(member_id_y1, member_flags_y1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y1, common_y1_ec))};
            if (!common_y1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y1 = "y1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y1;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y1 = TypeObjectUtils::build_complete_member_detail(name_y1, member_ann_builtin_y1, ann_custom_SamplePoints);
            CompleteStructMember member_y1 = TypeObjectUtils::build_complete_struct_member(common_y1, detail_y1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y1);
        }
        {
            TypeIdentifierPair type_ids_z1;
            ReturnCode_t return_code_z1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z1)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z1 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z1 = 0x00000003;
            bool common_z1_ec {false};
            CommonStructMember common_z1 {TypeObjectUtils::build_common_struct_member(member_id_z1, member_flags_z1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z1, common_z1_ec))};
            if (!common_z1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z1 = "z1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z1;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z1 = TypeObjectUtils::build_complete_member_detail(name_z1, member_ann_builtin_z1, ann_custom_SamplePoints);
            CompleteStructMember member_z1 = TypeObjectUtils::build_complete_struct_member(common_z1, detail_z1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z1);
        }
        {
            TypeIdentifierPair type_ids_o1;
            ReturnCode_t return_code_o1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o1)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o1);
            }
            StructMemberFlag member_flags_o1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o1 = 0x00000004;
            bool common_o1_ec {false};
            CommonStructMember common_o1 {TypeObjectUtils::build_common_struct_member(member_id_o1, member_flags_o1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o1, common_o1_ec))};
            if (!common_o1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o1 = "o1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o1;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o1 = TypeObjectUtils::build_complete_member_detail(name_o1, member_ann_builtin_o1, ann_custom_SamplePoints);
            CompleteStructMember member_o1 = TypeObjectUtils::build_complete_struct_member(common_o1, detail_o1);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o1);
        }
        {
            TypeIdentifierPair type_ids_x2;
            ReturnCode_t return_code_x2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x2)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x2 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x2 = 0x00000005;
            bool common_x2_ec {false};
            CommonStructMember common_x2 {TypeObjectUtils::build_common_struct_member(member_id_x2, member_flags_x2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x2, common_x2_ec))};
            if (!common_x2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x2 = "x2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x2;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x2 = TypeObjectUtils::build_complete_member_detail(name_x2, member_ann_builtin_x2, ann_custom_SamplePoints);
            CompleteStructMember member_x2 = TypeObjectUtils::build_complete_struct_member(common_x2, detail_x2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x2);
        }
        {
            TypeIdentifierPair type_ids_y2;
            ReturnCode_t return_code_y2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y2)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y2 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y2 = 0x00000006;
            bool common_y2_ec {false};
            CommonStructMember common_y2 {TypeObjectUtils::build_common_struct_member(member_id_y2, member_flags_y2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y2, common_y2_ec))};
            if (!common_y2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y2 = "y2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y2;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y2 = TypeObjectUtils::build_complete_member_detail(name_y2, member_ann_builtin_y2, ann_custom_SamplePoints);
            CompleteStructMember member_y2 = TypeObjectUtils::build_complete_struct_member(common_y2, detail_y2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y2);
        }
        {
            TypeIdentifierPair type_ids_z2;
            ReturnCode_t return_code_z2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z2)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z2 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z2 = 0x00000007;
            bool common_z2_ec {false};
            CommonStructMember common_z2 {TypeObjectUtils::build_common_struct_member(member_id_z2, member_flags_z2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z2, common_z2_ec))};
            if (!common_z2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z2 = "z2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z2;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z2 = TypeObjectUtils::build_complete_member_detail(name_z2, member_ann_builtin_z2, ann_custom_SamplePoints);
            CompleteStructMember member_z2 = TypeObjectUtils::build_complete_struct_member(common_z2, detail_z2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z2);
        }
        {
            TypeIdentifierPair type_ids_o2;
            ReturnCode_t return_code_o2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o2)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o2);
            }
            StructMemberFlag member_flags_o2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o2 = 0x00000008;
            bool common_o2_ec {false};
            CommonStructMember common_o2 {TypeObjectUtils::build_common_struct_member(member_id_o2, member_flags_o2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o2, common_o2_ec))};
            if (!common_o2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o2 = "o2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o2;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o2 = TypeObjectUtils::build_complete_member_detail(name_o2, member_ann_builtin_o2, ann_custom_SamplePoints);
            CompleteStructMember member_o2 = TypeObjectUtils::build_complete_struct_member(common_o2, detail_o2);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o2);
        }
        {
            TypeIdentifierPair type_ids_x3;
            ReturnCode_t return_code_x3 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x3 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x3);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x3)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x3 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x3 = 0x00000009;
            bool common_x3_ec {false};
            CommonStructMember common_x3 {TypeObjectUtils::build_common_struct_member(member_id_x3, member_flags_x3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x3, common_x3_ec))};
            if (!common_x3_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x3 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x3 = "x3";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x3;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x3 = TypeObjectUtils::build_complete_member_detail(name_x3, member_ann_builtin_x3, ann_custom_SamplePoints);
            CompleteStructMember member_x3 = TypeObjectUtils::build_complete_struct_member(common_x3, detail_x3);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x3);
        }
        {
            TypeIdentifierPair type_ids_y3;
            ReturnCode_t return_code_y3 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y3 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y3);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y3)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y3 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y3 = 0x0000000a;
            bool common_y3_ec {false};
            CommonStructMember common_y3 {TypeObjectUtils::build_common_struct_member(member_id_y3, member_flags_y3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y3, common_y3_ec))};
            if (!common_y3_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y3 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y3 = "y3";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y3;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y3 = TypeObjectUtils::build_complete_member_detail(name_y3, member_ann_builtin_y3, ann_custom_SamplePoints);
            CompleteStructMember member_y3 = TypeObjectUtils::build_complete_struct_member(common_y3, detail_y3);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y3);
        }
        {
            TypeIdentifierPair type_ids_z3;
            ReturnCode_t return_code_z3 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z3 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z3);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z3)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z3 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z3 = 0x0000000b;
            bool common_z3_ec {false};
            CommonStructMember common_z3 {TypeObjectUtils::build_common_struct_member(member_id_z3, member_flags_z3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z3, common_z3_ec))};
            if (!common_z3_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z3 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z3 = "z3";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z3;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z3 = TypeObjectUtils::build_complete_member_detail(name_z3, member_ann_builtin_z3, ann_custom_SamplePoints);
            CompleteStructMember member_z3 = TypeObjectUtils::build_complete_struct_member(common_z3, detail_z3);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z3);
        }
        {
            TypeIdentifierPair type_ids_o3;
            ReturnCode_t return_code_o3 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o3 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o3);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o3)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o3);
            }
            StructMemberFlag member_flags_o3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o3 = 0x0000000c;
            bool common_o3_ec {false};
            CommonStructMember common_o3 {TypeObjectUtils::build_common_struct_member(member_id_o3, member_flags_o3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o3, common_o3_ec))};
            if (!common_o3_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o3 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o3 = "o3";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o3;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o3 = TypeObjectUtils::build_complete_member_detail(name_o3, member_ann_builtin_o3, ann_custom_SamplePoints);
            CompleteStructMember member_o3 = TypeObjectUtils::build_complete_struct_member(common_o3, detail_o3);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o3);
        }
        {
            TypeIdentifierPair type_ids_x4;
            ReturnCode_t return_code_x4 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x4 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x4);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x4)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x4 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x4 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x4 = 0x0000000d;
            bool common_x4_ec {false};
            CommonStructMember common_x4 {TypeObjectUtils::build_common_struct_member(member_id_x4, member_flags_x4, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x4, common_x4_ec))};
            if (!common_x4_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x4 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x4 = "x4";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x4;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x4 = TypeObjectUtils::build_complete_member_detail(name_x4, member_ann_builtin_x4, ann_custom_SamplePoints);
            CompleteStructMember member_x4 = TypeObjectUtils::build_complete_struct_member(common_x4, detail_x4);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x4);
        }
        {
            TypeIdentifierPair type_ids_y4;
            ReturnCode_t return_code_y4 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y4 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y4);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y4)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y4 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y4 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y4 = 0x0000000e;
            bool common_y4_ec {false};
            CommonStructMember common_y4 {TypeObjectUtils::build_common_struct_member(member_id_y4, member_flags_y4, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y4, common_y4_ec))};
            if (!common_y4_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y4 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y4 = "y4";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y4;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y4 = TypeObjectUtils::build_complete_member_detail(name_y4, member_ann_builtin_y4, ann_custom_SamplePoints);
            CompleteStructMember member_y4 = TypeObjectUtils::build_complete_struct_member(common_y4, detail_y4);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y4);
        }
        {
            TypeIdentifierPair type_ids_z4;
            ReturnCode_t return_code_z4 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z4 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z4);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z4)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z4 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z4 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z4 = 0x0000000f;
            bool common_z4_ec {false};
            CommonStructMember common_z4 {TypeObjectUtils::build_common_struct_member(member_id_z4, member_flags_z4, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z4, common_z4_ec))};
            if (!common_z4_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z4 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z4 = "z4";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z4;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z4 = TypeObjectUtils::build_complete_member_detail(name_z4, member_ann_builtin_z4, ann_custom_SamplePoints);
            CompleteStructMember member_z4 = TypeObjectUtils::build_complete_struct_member(common_z4, detail_z4);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z4);
        }
        {
            TypeIdentifierPair type_ids_o4;
            ReturnCode_t return_code_o4 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o4 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o4);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o4)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o4);
            }
            StructMemberFlag member_flags_o4 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o4 = 0x00000010;
            bool common_o4_ec {false};
            CommonStructMember common_o4 {TypeObjectUtils::build_common_struct_member(member_id_o4, member_flags_o4, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o4, common_o4_ec))};
            if (!common_o4_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o4 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o4 = "o4";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o4;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o4 = TypeObjectUtils::build_complete_member_detail(name_o4, member_ann_builtin_o4, ann_custom_SamplePoints);
            CompleteStructMember member_o4 = TypeObjectUtils::build_complete_struct_member(common_o4, detail_o4);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o4);
        }
        {
            TypeIdentifierPair type_ids_x5;
            ReturnCode_t return_code_x5 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x5 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x5);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x5)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x5 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x5 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x5 = 0x00000011;
            bool common_x5_ec {false};
            CommonStructMember common_x5 {TypeObjectUtils::build_common_struct_member(member_id_x5, member_flags_x5, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x5, common_x5_ec))};
            if (!common_x5_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x5 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x5 = "x5";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x5;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x5 = TypeObjectUtils::build_complete_member_detail(name_x5, member_ann_builtin_x5, ann_custom_SamplePoints);
            CompleteStructMember member_x5 = TypeObjectUtils::build_complete_struct_member(common_x5, detail_x5);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x5);
        }
        {
            TypeIdentifierPair type_ids_y5;
            ReturnCode_t return_code_y5 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y5 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y5);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y5)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y5 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y5 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y5 = 0x00000012;
            bool common_y5_ec {false};
            CommonStructMember common_y5 {TypeObjectUtils::build_common_struct_member(member_id_y5, member_flags_y5, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y5, common_y5_ec))};
            if (!common_y5_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y5 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y5 = "y5";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y5;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y5 = TypeObjectUtils::build_complete_member_detail(name_y5, member_ann_builtin_y5, ann_custom_SamplePoints);
            CompleteStructMember member_y5 = TypeObjectUtils::build_complete_struct_member(common_y5, detail_y5);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y5);
        }
        {
            TypeIdentifierPair type_ids_z5;
            ReturnCode_t return_code_z5 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z5 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z5);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z5)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z5 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z5 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z5 = 0x00000013;
            bool common_z5_ec {false};
            CommonStructMember common_z5 {TypeObjectUtils::build_common_struct_member(member_id_z5, member_flags_z5, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z5, common_z5_ec))};
            if (!common_z5_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z5 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z5 = "z5";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z5;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z5 = TypeObjectUtils::build_complete_member_detail(name_z5, member_ann_builtin_z5, ann_custom_SamplePoints);
            CompleteStructMember member_z5 = TypeObjectUtils::build_complete_struct_member(common_z5, detail_z5);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z5);
        }
        {
            TypeIdentifierPair type_ids_o5;
            ReturnCode_t return_code_o5 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o5 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o5);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o5)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o5);
            }
            StructMemberFlag member_flags_o5 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o5 = 0x00000014;
            bool common_o5_ec {false};
            CommonStructMember common_o5 {TypeObjectUtils::build_common_struct_member(member_id_o5, member_flags_o5, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o5, common_o5_ec))};
            if (!common_o5_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o5 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o5 = "o5";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o5;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o5 = TypeObjectUtils::build_complete_member_detail(name_o5, member_ann_builtin_o5, ann_custom_SamplePoints);
            CompleteStructMember member_o5 = TypeObjectUtils::build_complete_struct_member(common_o5, detail_o5);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o5);
        }
        {
            TypeIdentifierPair type_ids_x6;
            ReturnCode_t return_code_x6 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_x6 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_x6);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_x6)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "x6 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_x6 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_x6 = 0x00000015;
            bool common_x6_ec {false};
            CommonStructMember common_x6 {TypeObjectUtils::build_common_struct_member(member_id_x6, member_flags_x6, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x6, common_x6_ec))};
            if (!common_x6_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x6 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_x6 = "x6";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_x6;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_x6 = TypeObjectUtils::build_complete_member_detail(name_x6, member_ann_builtin_x6, ann_custom_SamplePoints);
            CompleteStructMember member_x6 = TypeObjectUtils::build_complete_struct_member(common_x6, detail_x6);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_x6);
        }
        {
            TypeIdentifierPair type_ids_y6;
            ReturnCode_t return_code_y6 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_y6 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_y6);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_y6)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "y6 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_y6 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_y6 = 0x00000016;
            bool common_y6_ec {false};
            CommonStructMember common_y6 {TypeObjectUtils::build_common_struct_member(member_id_y6, member_flags_y6, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y6, common_y6_ec))};
            if (!common_y6_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y6 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_y6 = "y6";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_y6;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_y6 = TypeObjectUtils::build_complete_member_detail(name_y6, member_ann_builtin_y6, ann_custom_SamplePoints);
            CompleteStructMember member_y6 = TypeObjectUtils::build_complete_struct_member(common_y6, detail_y6);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_y6);
        }
        {
            TypeIdentifierPair type_ids_z6;
            ReturnCode_t return_code_z6 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_z6 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint16_t", type_ids_z6);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_z6)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "z6 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_z6 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_z6 = 0x00000017;
            bool common_z6_ec {false};
            CommonStructMember common_z6 {TypeObjectUtils::build_common_struct_member(member_id_z6, member_flags_z6, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_z6, common_z6_ec))};
            if (!common_z6_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure z6 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_z6 = "z6";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_z6;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_z6 = TypeObjectUtils::build_complete_member_detail(name_z6, member_ann_builtin_z6, ann_custom_SamplePoints);
            CompleteStructMember member_z6 = TypeObjectUtils::build_complete_struct_member(common_z6, detail_z6);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_z6);
        }
        {
            TypeIdentifierPair type_ids_o6;
            ReturnCode_t return_code_o6 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_o6 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "SampleModule::DropChoice", type_ids_o6);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_o6)
            {
                SampleModule::register_DropChoice_type_identifier(type_ids_o6);
            }
            StructMemberFlag member_flags_o6 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_o6 = 0x00000018;
            bool common_o6_ec {false};
            CommonStructMember common_o6 {TypeObjectUtils::build_common_struct_member(member_id_o6, member_flags_o6, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_o6, common_o6_ec))};
            if (!common_o6_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure o6 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_o6 = "o6";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_o6;
            ann_custom_SamplePoints.reset();
            CompleteMemberDetail detail_o6 = TypeObjectUtils::build_complete_member_detail(name_o6, member_ann_builtin_o6, ann_custom_SamplePoints);
            CompleteStructMember member_o6 = TypeObjectUtils::build_complete_struct_member(common_o6, detail_o6);
            TypeObjectUtils::add_complete_struct_member(member_seq_SamplePoints, member_o6);
        }
        CompleteStructType struct_type_SamplePoints = TypeObjectUtils::build_complete_struct_type(struct_flags_SamplePoints, header_SamplePoints, member_seq_SamplePoints);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SamplePoints, type_name_SamplePoints.to_string(), type_ids_SamplePoints))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "SampleModule::SamplePoints already registered in TypeObjectRegistry for a different type.");
        }
    }
}

} // namespace SampleModule

