// 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 WeighingDDSTypeTypeObjectSupport.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 "WeighingDDSTypeTypeObjectSupport.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 "WeighingDDSType.hpp"


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

namespace WeighingSystem {
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_ScaleInfo_type_identifier(
        TypeIdentifierPair& type_ids_ScaleInfo)
{

    ReturnCode_t return_code_ScaleInfo {eprosima::fastdds::dds::RETCODE_OK};
    return_code_ScaleInfo =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::ScaleInfo", type_ids_ScaleInfo);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ScaleInfo)
    {
        StructTypeFlag struct_flags_ScaleInfo = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_ScaleInfo = "WeighingSystem::ScaleInfo";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ScaleInfo;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ScaleInfo;
        CompleteTypeDetail detail_ScaleInfo = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ScaleInfo, ann_custom_ScaleInfo, type_name_ScaleInfo.to_string());
        CompleteStructHeader header_ScaleInfo;
        header_ScaleInfo = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ScaleInfo);
        CompleteStructMemberSeq member_seq_ScaleInfo;
        {
            TypeIdentifierPair type_ids_HasVehicle;
            ReturnCode_t return_code_HasVehicle {eprosima::fastdds::dds::RETCODE_OK};
            return_code_HasVehicle =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_HasVehicle);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_HasVehicle)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "HasVehicle Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_HasVehicle = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_HasVehicle = 0x00000000;
            bool common_HasVehicle_ec {false};
            CommonStructMember common_HasVehicle {TypeObjectUtils::build_common_struct_member(member_id_HasVehicle, member_flags_HasVehicle, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_HasVehicle, common_HasVehicle_ec))};
            if (!common_HasVehicle_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure HasVehicle member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_HasVehicle = "HasVehicle";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_HasVehicle;
            ann_custom_ScaleInfo.reset();
            CompleteMemberDetail detail_HasVehicle = TypeObjectUtils::build_complete_member_detail(name_HasVehicle, member_ann_builtin_HasVehicle, ann_custom_ScaleInfo);
            CompleteStructMember member_HasVehicle = TypeObjectUtils::build_complete_struct_member(common_HasVehicle, detail_HasVehicle);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_HasVehicle);
        }
        {
            TypeIdentifierPair type_ids_WeightOK;
            ReturnCode_t return_code_WeightOK {eprosima::fastdds::dds::RETCODE_OK};
            return_code_WeightOK =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_WeightOK);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightOK)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "WeightOK Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_WeightOK = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_WeightOK = 0x00000001;
            bool common_WeightOK_ec {false};
            CommonStructMember common_WeightOK {TypeObjectUtils::build_common_struct_member(member_id_WeightOK, member_flags_WeightOK, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_WeightOK, common_WeightOK_ec))};
            if (!common_WeightOK_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure WeightOK member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_WeightOK = "WeightOK";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_WeightOK;
            ann_custom_ScaleInfo.reset();
            CompleteMemberDetail detail_WeightOK = TypeObjectUtils::build_complete_member_detail(name_WeightOK, member_ann_builtin_WeightOK, ann_custom_ScaleInfo);
            CompleteStructMember member_WeightOK = TypeObjectUtils::build_complete_struct_member(common_WeightOK, detail_WeightOK);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_WeightOK);
        }
        {
            TypeIdentifierPair type_ids_State;
            ReturnCode_t return_code_State {eprosima::fastdds::dds::RETCODE_OK};
            return_code_State =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_State);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_State)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "State Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_State = 0x00000002;
            bool common_State_ec {false};
            CommonStructMember common_State {TypeObjectUtils::build_common_struct_member(member_id_State, member_flags_State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_State, common_State_ec))};
            if (!common_State_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure State member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_State = "State";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_State;
            ann_custom_ScaleInfo.reset();
            CompleteMemberDetail detail_State = TypeObjectUtils::build_complete_member_detail(name_State, member_ann_builtin_State, ann_custom_ScaleInfo);
            CompleteStructMember member_State = TypeObjectUtils::build_complete_struct_member(common_State, detail_State);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_State);
        }
        {
            TypeIdentifierPair type_ids_Value;
            ReturnCode_t return_code_Value {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Value =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_Value);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Value)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "Value Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_Value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Value = 0x00000003;
            bool common_Value_ec {false};
            CommonStructMember common_Value {TypeObjectUtils::build_common_struct_member(member_id_Value, member_flags_Value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Value, common_Value_ec))};
            if (!common_Value_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Value member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Value = "Value";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Value;
            ann_custom_ScaleInfo.reset();
            CompleteMemberDetail detail_Value = TypeObjectUtils::build_complete_member_detail(name_Value, member_ann_builtin_Value, ann_custom_ScaleInfo);
            CompleteStructMember member_Value = TypeObjectUtils::build_complete_struct_member(common_Value, detail_Value);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_Value);
        }
        {
            TypeIdentifierPair type_ids_StableValue;
            ReturnCode_t return_code_StableValue {eprosima::fastdds::dds::RETCODE_OK};
            return_code_StableValue =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_StableValue);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_StableValue)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "StableValue Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_StableValue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_StableValue = 0x00000004;
            bool common_StableValue_ec {false};
            CommonStructMember common_StableValue {TypeObjectUtils::build_common_struct_member(member_id_StableValue, member_flags_StableValue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_StableValue, common_StableValue_ec))};
            if (!common_StableValue_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure StableValue member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_StableValue = "StableValue";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_StableValue;
            ann_custom_ScaleInfo.reset();
            CompleteMemberDetail detail_StableValue = TypeObjectUtils::build_complete_member_detail(name_StableValue, member_ann_builtin_StableValue, ann_custom_ScaleInfo);
            CompleteStructMember member_StableValue = TypeObjectUtils::build_complete_struct_member(common_StableValue, detail_StableValue);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_StableValue);
        }
        CompleteStructType struct_type_ScaleInfo = TypeObjectUtils::build_complete_struct_type(struct_flags_ScaleInfo, header_ScaleInfo, member_seq_ScaleInfo);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ScaleInfo, type_name_ScaleInfo.to_string(), type_ids_ScaleInfo))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::ScaleInfo already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_ScaleCommand_type_identifier(
        TypeIdentifierPair& type_ids_ScaleCommand)
{

    ReturnCode_t return_code_ScaleCommand {eprosima::fastdds::dds::RETCODE_OK};
    return_code_ScaleCommand =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::ScaleCommand", type_ids_ScaleCommand);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ScaleCommand)
    {
        StructTypeFlag struct_flags_ScaleCommand = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_ScaleCommand = "WeighingSystem::ScaleCommand";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ScaleCommand;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ScaleCommand;
        CompleteTypeDetail detail_ScaleCommand = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ScaleCommand, ann_custom_ScaleCommand, type_name_ScaleCommand.to_string());
        CompleteStructHeader header_ScaleCommand;
        header_ScaleCommand = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ScaleCommand);
        CompleteStructMemberSeq member_seq_ScaleCommand;
        {
            TypeIdentifierPair type_ids_Enable;
            ReturnCode_t return_code_Enable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Enable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_Enable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Enable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "Enable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_Enable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Enable = 0x00000000;
            bool common_Enable_ec {false};
            CommonStructMember common_Enable {TypeObjectUtils::build_common_struct_member(member_id_Enable, member_flags_Enable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Enable, common_Enable_ec))};
            if (!common_Enable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Enable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Enable = "Enable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Enable;
            ann_custom_ScaleCommand.reset();
            CompleteMemberDetail detail_Enable = TypeObjectUtils::build_complete_member_detail(name_Enable, member_ann_builtin_Enable, ann_custom_ScaleCommand);
            CompleteStructMember member_Enable = TypeObjectUtils::build_complete_struct_member(common_Enable, detail_Enable);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleCommand, member_Enable);
        }
        {
            TypeIdentifierPair type_ids_ResetZero;
            ReturnCode_t return_code_ResetZero {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ResetZero =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_ResetZero);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ResetZero)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "ResetZero Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_ResetZero = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ResetZero = 0x00000001;
            bool common_ResetZero_ec {false};
            CommonStructMember common_ResetZero {TypeObjectUtils::build_common_struct_member(member_id_ResetZero, member_flags_ResetZero, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ResetZero, common_ResetZero_ec))};
            if (!common_ResetZero_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ResetZero member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ResetZero = "ResetZero";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ResetZero;
            ann_custom_ScaleCommand.reset();
            CompleteMemberDetail detail_ResetZero = TypeObjectUtils::build_complete_member_detail(name_ResetZero, member_ann_builtin_ResetZero, ann_custom_ScaleCommand);
            CompleteStructMember member_ResetZero = TypeObjectUtils::build_complete_struct_member(common_ResetZero, detail_ResetZero);
            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleCommand, member_ResetZero);
        }
        CompleteStructType struct_type_ScaleCommand = TypeObjectUtils::build_complete_struct_type(struct_flags_ScaleCommand, header_ScaleCommand, member_seq_ScaleCommand);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ScaleCommand, type_name_ScaleCommand.to_string(), type_ids_ScaleCommand))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::ScaleCommand already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_WeightInfoOk_type_identifier(
        TypeIdentifierPair& type_ids_WeightInfoOk)
{

    ReturnCode_t return_code_WeightInfoOk {eprosima::fastdds::dds::RETCODE_OK};
    return_code_WeightInfoOk =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::WeightInfoOk", type_ids_WeightInfoOk);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightInfoOk)
    {
        StructTypeFlag struct_flags_WeightInfoOk = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_WeightInfoOk = "WeighingSystem::WeightInfoOk";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_WeightInfoOk;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_WeightInfoOk;
        CompleteTypeDetail detail_WeightInfoOk = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_WeightInfoOk, ann_custom_WeightInfoOk, type_name_WeightInfoOk.to_string());
        CompleteStructHeader header_WeightInfoOk;
        header_WeightInfoOk = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_WeightInfoOk);
        CompleteStructMemberSeq member_seq_WeightInfoOk;
        {
            TypeIdentifierPair type_ids_GrossDeviceID;
            ReturnCode_t return_code_GrossDeviceID {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossDeviceID =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_GrossDeviceID);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceID)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "GrossDeviceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_GrossDeviceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossDeviceID = 0x00000000;
            bool common_GrossDeviceID_ec {false};
            CommonStructMember common_GrossDeviceID {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceID, member_flags_GrossDeviceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceID, common_GrossDeviceID_ec))};
            if (!common_GrossDeviceID_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceID member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossDeviceID = "GrossDeviceID";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceID;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossDeviceID = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceID, member_ann_builtin_GrossDeviceID, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossDeviceID = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceID, detail_GrossDeviceID);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceID);
        }
        {
            TypeIdentifierPair type_ids_GrossDeviceName;
            ReturnCode_t return_code_GrossDeviceName {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossDeviceName =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_GrossDeviceName);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceName)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_GrossDeviceName))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_GrossDeviceName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossDeviceName = 0x00000001;
            bool common_GrossDeviceName_ec {false};
            CommonStructMember common_GrossDeviceName {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceName, member_flags_GrossDeviceName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceName, common_GrossDeviceName_ec))};
            if (!common_GrossDeviceName_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceName member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossDeviceName = "GrossDeviceName";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceName;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossDeviceName = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceName, member_ann_builtin_GrossDeviceName, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossDeviceName = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceName, detail_GrossDeviceName);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceName);
        }
        {
            TypeIdentifierPair type_ids_GrossDeviceType;
            ReturnCode_t return_code_GrossDeviceType {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossDeviceType =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_GrossDeviceType);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceType)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_GrossDeviceType))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_GrossDeviceType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossDeviceType = 0x00000002;
            bool common_GrossDeviceType_ec {false};
            CommonStructMember common_GrossDeviceType {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceType, member_flags_GrossDeviceType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceType, common_GrossDeviceType_ec))};
            if (!common_GrossDeviceType_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceType member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossDeviceType = "GrossDeviceType";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceType;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossDeviceType = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceType, member_ann_builtin_GrossDeviceType, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossDeviceType = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceType, detail_GrossDeviceType);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceType);
        }
        {
            TypeIdentifierPair type_ids_TareDeviceID;
            ReturnCode_t return_code_TareDeviceID {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TareDeviceID =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_TareDeviceID);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceID)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "TareDeviceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_TareDeviceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TareDeviceID = 0x00000003;
            bool common_TareDeviceID_ec {false};
            CommonStructMember common_TareDeviceID {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceID, member_flags_TareDeviceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceID, common_TareDeviceID_ec))};
            if (!common_TareDeviceID_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceID member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TareDeviceID = "TareDeviceID";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceID;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TareDeviceID = TypeObjectUtils::build_complete_member_detail(name_TareDeviceID, member_ann_builtin_TareDeviceID, ann_custom_WeightInfoOk);
            CompleteStructMember member_TareDeviceID = TypeObjectUtils::build_complete_struct_member(common_TareDeviceID, detail_TareDeviceID);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceID);
        }
        {
            TypeIdentifierPair type_ids_TareDeviceName;
            ReturnCode_t return_code_TareDeviceName {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TareDeviceName =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TareDeviceName);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceName)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TareDeviceName))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TareDeviceName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TareDeviceName = 0x00000004;
            bool common_TareDeviceName_ec {false};
            CommonStructMember common_TareDeviceName {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceName, member_flags_TareDeviceName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceName, common_TareDeviceName_ec))};
            if (!common_TareDeviceName_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceName member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TareDeviceName = "TareDeviceName";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceName;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TareDeviceName = TypeObjectUtils::build_complete_member_detail(name_TareDeviceName, member_ann_builtin_TareDeviceName, ann_custom_WeightInfoOk);
            CompleteStructMember member_TareDeviceName = TypeObjectUtils::build_complete_struct_member(common_TareDeviceName, detail_TareDeviceName);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceName);
        }
        {
            TypeIdentifierPair type_ids_TareDeviceType;
            ReturnCode_t return_code_TareDeviceType {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TareDeviceType =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TareDeviceType);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceType)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TareDeviceType))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TareDeviceType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TareDeviceType = 0x00000005;
            bool common_TareDeviceType_ec {false};
            CommonStructMember common_TareDeviceType {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceType, member_flags_TareDeviceType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceType, common_TareDeviceType_ec))};
            if (!common_TareDeviceType_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceType member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TareDeviceType = "TareDeviceType";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceType;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TareDeviceType = TypeObjectUtils::build_complete_member_detail(name_TareDeviceType, member_ann_builtin_TareDeviceType, ann_custom_WeightInfoOk);
            CompleteStructMember member_TareDeviceType = TypeObjectUtils::build_complete_struct_member(common_TareDeviceType, detail_TareDeviceType);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceType);
        }
        {
            TypeIdentifierPair type_ids_EnterpriseName;
            ReturnCode_t return_code_EnterpriseName {eprosima::fastdds::dds::RETCODE_OK};
            return_code_EnterpriseName =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_EnterpriseName);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_EnterpriseName)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_EnterpriseName))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_EnterpriseName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_EnterpriseName = 0x00000006;
            bool common_EnterpriseName_ec {false};
            CommonStructMember common_EnterpriseName {TypeObjectUtils::build_common_struct_member(member_id_EnterpriseName, member_flags_EnterpriseName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_EnterpriseName, common_EnterpriseName_ec))};
            if (!common_EnterpriseName_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure EnterpriseName member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_EnterpriseName = "EnterpriseName";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_EnterpriseName;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_EnterpriseName = TypeObjectUtils::build_complete_member_detail(name_EnterpriseName, member_ann_builtin_EnterpriseName, ann_custom_WeightInfoOk);
            CompleteStructMember member_EnterpriseName = TypeObjectUtils::build_complete_struct_member(common_EnterpriseName, detail_EnterpriseName);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_EnterpriseName);
        }
        {
            TypeIdentifierPair type_ids_BillNumber;
            ReturnCode_t return_code_BillNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BillNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_BillNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BillNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_BillNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_BillNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BillNumber = 0x00000007;
            bool common_BillNumber_ec {false};
            CommonStructMember common_BillNumber {TypeObjectUtils::build_common_struct_member(member_id_BillNumber, member_flags_BillNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BillNumber, common_BillNumber_ec))};
            if (!common_BillNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BillNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BillNumber = "BillNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BillNumber;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_BillNumber = TypeObjectUtils::build_complete_member_detail(name_BillNumber, member_ann_builtin_BillNumber, ann_custom_WeightInfoOk);
            CompleteStructMember member_BillNumber = TypeObjectUtils::build_complete_struct_member(common_BillNumber, detail_BillNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_BillNumber);
        }
        {
            TypeIdentifierPair type_ids_CarNumber;
            ReturnCode_t return_code_CarNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_CarNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_CarNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_CarNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_CarNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_CarNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_CarNumber = 0x00000008;
            bool common_CarNumber_ec {false};
            CommonStructMember common_CarNumber {TypeObjectUtils::build_common_struct_member(member_id_CarNumber, member_flags_CarNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_CarNumber, common_CarNumber_ec))};
            if (!common_CarNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure CarNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_CarNumber = "CarNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_CarNumber;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_CarNumber = TypeObjectUtils::build_complete_member_detail(name_CarNumber, member_ann_builtin_CarNumber, ann_custom_WeightInfoOk);
            CompleteStructMember member_CarNumber = TypeObjectUtils::build_complete_struct_member(common_CarNumber, detail_CarNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_CarNumber);
        }
        {
            TypeIdentifierPair type_ids_Supplier;
            ReturnCode_t return_code_Supplier {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Supplier =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_Supplier);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Supplier)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_Supplier))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_Supplier = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Supplier = 0x00000009;
            bool common_Supplier_ec {false};
            CommonStructMember common_Supplier {TypeObjectUtils::build_common_struct_member(member_id_Supplier, member_flags_Supplier, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Supplier, common_Supplier_ec))};
            if (!common_Supplier_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Supplier member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Supplier = "Supplier";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Supplier;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_Supplier = TypeObjectUtils::build_complete_member_detail(name_Supplier, member_ann_builtin_Supplier, ann_custom_WeightInfoOk);
            CompleteStructMember member_Supplier = TypeObjectUtils::build_complete_struct_member(common_Supplier, detail_Supplier);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Supplier);
        }
        {
            TypeIdentifierPair type_ids_GoodsType;
            ReturnCode_t return_code_GoodsType {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GoodsType =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_GoodsType);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GoodsType)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_GoodsType))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_GoodsType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GoodsType = 0x0000000a;
            bool common_GoodsType_ec {false};
            CommonStructMember common_GoodsType {TypeObjectUtils::build_common_struct_member(member_id_GoodsType, member_flags_GoodsType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GoodsType, common_GoodsType_ec))};
            if (!common_GoodsType_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GoodsType member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GoodsType = "GoodsType";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GoodsType;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GoodsType = TypeObjectUtils::build_complete_member_detail(name_GoodsType, member_ann_builtin_GoodsType, ann_custom_WeightInfoOk);
            CompleteStructMember member_GoodsType = TypeObjectUtils::build_complete_struct_member(common_GoodsType, detail_GoodsType);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GoodsType);
        }
        {
            TypeIdentifierPair type_ids_GrossWeight;
            ReturnCode_t return_code_GrossWeight {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossWeight =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_GrossWeight);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossWeight)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "GrossWeight Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_GrossWeight = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossWeight = 0x0000000b;
            bool common_GrossWeight_ec {false};
            CommonStructMember common_GrossWeight {TypeObjectUtils::build_common_struct_member(member_id_GrossWeight, member_flags_GrossWeight, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossWeight, common_GrossWeight_ec))};
            if (!common_GrossWeight_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossWeight member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossWeight = "GrossWeight";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossWeight;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossWeight = TypeObjectUtils::build_complete_member_detail(name_GrossWeight, member_ann_builtin_GrossWeight, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossWeight = TypeObjectUtils::build_complete_struct_member(common_GrossWeight, detail_GrossWeight);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossWeight);
        }
        {
            TypeIdentifierPair type_ids_GrossTime;
            ReturnCode_t return_code_GrossTime {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossTime =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_GrossTime);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossTime)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_GrossTime))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_GrossTime = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossTime = 0x0000000c;
            bool common_GrossTime_ec {false};
            CommonStructMember common_GrossTime {TypeObjectUtils::build_common_struct_member(member_id_GrossTime, member_flags_GrossTime, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossTime, common_GrossTime_ec))};
            if (!common_GrossTime_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossTime member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossTime = "GrossTime";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossTime;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossTime = TypeObjectUtils::build_complete_member_detail(name_GrossTime, member_ann_builtin_GrossTime, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossTime = TypeObjectUtils::build_complete_struct_member(common_GrossTime, detail_GrossTime);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossTime);
        }
        {
            TypeIdentifierPair type_ids_GrossOperater;
            ReturnCode_t return_code_GrossOperater {eprosima::fastdds::dds::RETCODE_OK};
            return_code_GrossOperater =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_GrossOperater);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossOperater)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_GrossOperater))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_GrossOperater = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_GrossOperater = 0x0000000d;
            bool common_GrossOperater_ec {false};
            CommonStructMember common_GrossOperater {TypeObjectUtils::build_common_struct_member(member_id_GrossOperater, member_flags_GrossOperater, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossOperater, common_GrossOperater_ec))};
            if (!common_GrossOperater_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossOperater member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_GrossOperater = "GrossOperater";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossOperater;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_GrossOperater = TypeObjectUtils::build_complete_member_detail(name_GrossOperater, member_ann_builtin_GrossOperater, ann_custom_WeightInfoOk);
            CompleteStructMember member_GrossOperater = TypeObjectUtils::build_complete_struct_member(common_GrossOperater, detail_GrossOperater);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossOperater);
        }
        {
            TypeIdentifierPair type_ids_Tare;
            ReturnCode_t return_code_Tare {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Tare =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_Tare);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Tare)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "Tare Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_Tare = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Tare = 0x0000000e;
            bool common_Tare_ec {false};
            CommonStructMember common_Tare {TypeObjectUtils::build_common_struct_member(member_id_Tare, member_flags_Tare, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Tare, common_Tare_ec))};
            if (!common_Tare_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Tare member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Tare = "Tare";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Tare;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_Tare = TypeObjectUtils::build_complete_member_detail(name_Tare, member_ann_builtin_Tare, ann_custom_WeightInfoOk);
            CompleteStructMember member_Tare = TypeObjectUtils::build_complete_struct_member(common_Tare, detail_Tare);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Tare);
        }
        {
            TypeIdentifierPair type_ids_TareTime;
            ReturnCode_t return_code_TareTime {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TareTime =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TareTime);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareTime)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TareTime))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TareTime = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TareTime = 0x0000000f;
            bool common_TareTime_ec {false};
            CommonStructMember common_TareTime {TypeObjectUtils::build_common_struct_member(member_id_TareTime, member_flags_TareTime, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareTime, common_TareTime_ec))};
            if (!common_TareTime_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareTime member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TareTime = "TareTime";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareTime;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TareTime = TypeObjectUtils::build_complete_member_detail(name_TareTime, member_ann_builtin_TareTime, ann_custom_WeightInfoOk);
            CompleteStructMember member_TareTime = TypeObjectUtils::build_complete_struct_member(common_TareTime, detail_TareTime);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareTime);
        }
        {
            TypeIdentifierPair type_ids_TareOperater;
            ReturnCode_t return_code_TareOperater {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TareOperater =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TareOperater);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareOperater)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TareOperater))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TareOperater = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TareOperater = 0x00000010;
            bool common_TareOperater_ec {false};
            CommonStructMember common_TareOperater {TypeObjectUtils::build_common_struct_member(member_id_TareOperater, member_flags_TareOperater, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareOperater, common_TareOperater_ec))};
            if (!common_TareOperater_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareOperater member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TareOperater = "TareOperater";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareOperater;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TareOperater = TypeObjectUtils::build_complete_member_detail(name_TareOperater, member_ann_builtin_TareOperater, ann_custom_WeightInfoOk);
            CompleteStructMember member_TareOperater = TypeObjectUtils::build_complete_struct_member(common_TareOperater, detail_TareOperater);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareOperater);
        }
        {
            TypeIdentifierPair type_ids_Suttle;
            ReturnCode_t return_code_Suttle {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Suttle =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_Suttle);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Suttle)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "Suttle Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_Suttle = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Suttle = 0x00000011;
            bool common_Suttle_ec {false};
            CommonStructMember common_Suttle {TypeObjectUtils::build_common_struct_member(member_id_Suttle, member_flags_Suttle, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Suttle, common_Suttle_ec))};
            if (!common_Suttle_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Suttle member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Suttle = "Suttle";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Suttle;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_Suttle = TypeObjectUtils::build_complete_member_detail(name_Suttle, member_ann_builtin_Suttle, ann_custom_WeightInfoOk);
            CompleteStructMember member_Suttle = TypeObjectUtils::build_complete_struct_member(common_Suttle, detail_Suttle);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Suttle);
        }
        {
            TypeIdentifierPair type_ids_duduction1;
            ReturnCode_t return_code_duduction1 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_duduction1 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_duduction1);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction1)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "duduction1 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_duduction1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_duduction1 = 0x00000012;
            bool common_duduction1_ec {false};
            CommonStructMember common_duduction1 {TypeObjectUtils::build_common_struct_member(member_id_duduction1, member_flags_duduction1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction1, common_duduction1_ec))};
            if (!common_duduction1_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction1 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_duduction1 = "duduction1";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction1;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_duduction1 = TypeObjectUtils::build_complete_member_detail(name_duduction1, member_ann_builtin_duduction1, ann_custom_WeightInfoOk);
            CompleteStructMember member_duduction1 = TypeObjectUtils::build_complete_struct_member(common_duduction1, detail_duduction1);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction1);
        }
        {
            TypeIdentifierPair type_ids_duduction2;
            ReturnCode_t return_code_duduction2 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_duduction2 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_duduction2);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction2)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "duduction2 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_duduction2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_duduction2 = 0x00000013;
            bool common_duduction2_ec {false};
            CommonStructMember common_duduction2 {TypeObjectUtils::build_common_struct_member(member_id_duduction2, member_flags_duduction2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction2, common_duduction2_ec))};
            if (!common_duduction2_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction2 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_duduction2 = "duduction2";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction2;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_duduction2 = TypeObjectUtils::build_complete_member_detail(name_duduction2, member_ann_builtin_duduction2, ann_custom_WeightInfoOk);
            CompleteStructMember member_duduction2 = TypeObjectUtils::build_complete_struct_member(common_duduction2, detail_duduction2);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction2);
        }
        {
            TypeIdentifierPair type_ids_duduction3;
            ReturnCode_t return_code_duduction3 {eprosima::fastdds::dds::RETCODE_OK};
            return_code_duduction3 =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_duduction3);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction3)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "duduction3 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_duduction3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_duduction3 = 0x00000014;
            bool common_duduction3_ec {false};
            CommonStructMember common_duduction3 {TypeObjectUtils::build_common_struct_member(member_id_duduction3, member_flags_duduction3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction3, common_duduction3_ec))};
            if (!common_duduction3_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction3 member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_duduction3 = "duduction3";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction3;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_duduction3 = TypeObjectUtils::build_complete_member_detail(name_duduction3, member_ann_builtin_duduction3, ann_custom_WeightInfoOk);
            CompleteStructMember member_duduction3 = TypeObjectUtils::build_complete_struct_member(common_duduction3, detail_duduction3);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction3);
        }
        {
            TypeIdentifierPair type_ids_INCoalYard;
            ReturnCode_t return_code_INCoalYard {eprosima::fastdds::dds::RETCODE_OK};
            return_code_INCoalYard =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_INCoalYard);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_INCoalYard)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_INCoalYard))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_INCoalYard = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_INCoalYard = 0x00000015;
            bool common_INCoalYard_ec {false};
            CommonStructMember common_INCoalYard {TypeObjectUtils::build_common_struct_member(member_id_INCoalYard, member_flags_INCoalYard, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_INCoalYard, common_INCoalYard_ec))};
            if (!common_INCoalYard_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure INCoalYard member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_INCoalYard = "INCoalYard";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_INCoalYard;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_INCoalYard = TypeObjectUtils::build_complete_member_detail(name_INCoalYard, member_ann_builtin_INCoalYard, ann_custom_WeightInfoOk);
            CompleteStructMember member_INCoalYard = TypeObjectUtils::build_complete_struct_member(common_INCoalYard, detail_INCoalYard);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_INCoalYard);
        }
        {
            TypeIdentifierPair type_ids_OutCoalYard;
            ReturnCode_t return_code_OutCoalYard {eprosima::fastdds::dds::RETCODE_OK};
            return_code_OutCoalYard =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_OutCoalYard);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_OutCoalYard)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_OutCoalYard))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_OutCoalYard = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_OutCoalYard = 0x00000016;
            bool common_OutCoalYard_ec {false};
            CommonStructMember common_OutCoalYard {TypeObjectUtils::build_common_struct_member(member_id_OutCoalYard, member_flags_OutCoalYard, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_OutCoalYard, common_OutCoalYard_ec))};
            if (!common_OutCoalYard_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure OutCoalYard member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_OutCoalYard = "OutCoalYard";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_OutCoalYard;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_OutCoalYard = TypeObjectUtils::build_complete_member_detail(name_OutCoalYard, member_ann_builtin_OutCoalYard, ann_custom_WeightInfoOk);
            CompleteStructMember member_OutCoalYard = TypeObjectUtils::build_complete_struct_member(common_OutCoalYard, detail_OutCoalYard);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_OutCoalYard);
        }
        {
            TypeIdentifierPair type_ids_BatchNumber;
            ReturnCode_t return_code_BatchNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BatchNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_BatchNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BatchNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_BatchNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_BatchNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BatchNumber = 0x00000017;
            bool common_BatchNumber_ec {false};
            CommonStructMember common_BatchNumber {TypeObjectUtils::build_common_struct_member(member_id_BatchNumber, member_flags_BatchNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BatchNumber, common_BatchNumber_ec))};
            if (!common_BatchNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BatchNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BatchNumber = "BatchNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BatchNumber;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_BatchNumber = TypeObjectUtils::build_complete_member_detail(name_BatchNumber, member_ann_builtin_BatchNumber, ann_custom_WeightInfoOk);
            CompleteStructMember member_BatchNumber = TypeObjectUtils::build_complete_struct_member(common_BatchNumber, detail_BatchNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_BatchNumber);
        }
        {
            TypeIdentifierPair type_ids_Warning;
            ReturnCode_t return_code_Warning {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Warning =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_Warning);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Warning)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_Warning))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_Warning = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Warning = 0x00000018;
            bool common_Warning_ec {false};
            CommonStructMember common_Warning {TypeObjectUtils::build_common_struct_member(member_id_Warning, member_flags_Warning, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Warning, common_Warning_ec))};
            if (!common_Warning_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Warning member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Warning = "Warning";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Warning;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_Warning = TypeObjectUtils::build_complete_member_detail(name_Warning, member_ann_builtin_Warning, ann_custom_WeightInfoOk);
            CompleteStructMember member_Warning = TypeObjectUtils::build_complete_struct_member(common_Warning, detail_Warning);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Warning);
        }
        {
            TypeIdentifierPair type_ids_Tips;
            ReturnCode_t return_code_Tips {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Tips =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_Tips);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Tips)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_Tips))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_Tips = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Tips = 0x00000019;
            bool common_Tips_ec {false};
            CommonStructMember common_Tips {TypeObjectUtils::build_common_struct_member(member_id_Tips, member_flags_Tips, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Tips, common_Tips_ec))};
            if (!common_Tips_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Tips member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Tips = "Tips";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Tips;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_Tips = TypeObjectUtils::build_complete_member_detail(name_Tips, member_ann_builtin_Tips, ann_custom_WeightInfoOk);
            CompleteStructMember member_Tips = TypeObjectUtils::build_complete_struct_member(common_Tips, detail_Tips);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Tips);
        }
        {
            TypeIdentifierPair type_ids_TicketType;
            ReturnCode_t return_code_TicketType {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TicketType =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TicketType);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TicketType)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TicketType))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TicketType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TicketType = 0x0000001a;
            bool common_TicketType_ec {false};
            CommonStructMember common_TicketType {TypeObjectUtils::build_common_struct_member(member_id_TicketType, member_flags_TicketType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TicketType, common_TicketType_ec))};
            if (!common_TicketType_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TicketType member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TicketType = "TicketType";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TicketType;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TicketType = TypeObjectUtils::build_complete_member_detail(name_TicketType, member_ann_builtin_TicketType, ann_custom_WeightInfoOk);
            CompleteStructMember member_TicketType = TypeObjectUtils::build_complete_struct_member(common_TicketType, detail_TicketType);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TicketType);
        }
        {
            TypeIdentifierPair type_ids_IsPrintTicker;
            ReturnCode_t return_code_IsPrintTicker {eprosima::fastdds::dds::RETCODE_OK};
            return_code_IsPrintTicker =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_IsPrintTicker);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_IsPrintTicker)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "IsPrintTicker Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_IsPrintTicker = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_IsPrintTicker = 0x0000001b;
            bool common_IsPrintTicker_ec {false};
            CommonStructMember common_IsPrintTicker {TypeObjectUtils::build_common_struct_member(member_id_IsPrintTicker, member_flags_IsPrintTicker, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_IsPrintTicker, common_IsPrintTicker_ec))};
            if (!common_IsPrintTicker_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure IsPrintTicker member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_IsPrintTicker = "IsPrintTicker";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_IsPrintTicker;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_IsPrintTicker = TypeObjectUtils::build_complete_member_detail(name_IsPrintTicker, member_ann_builtin_IsPrintTicker, ann_custom_WeightInfoOk);
            CompleteStructMember member_IsPrintTicker = TypeObjectUtils::build_complete_struct_member(common_IsPrintTicker, detail_IsPrintTicker);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_IsPrintTicker);
        }
        {
            TypeIdentifierPair type_ids_OrderNumber;
            ReturnCode_t return_code_OrderNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_OrderNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_OrderNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_OrderNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_OrderNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_OrderNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_OrderNumber = 0x0000001c;
            bool common_OrderNumber_ec {false};
            CommonStructMember common_OrderNumber {TypeObjectUtils::build_common_struct_member(member_id_OrderNumber, member_flags_OrderNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_OrderNumber, common_OrderNumber_ec))};
            if (!common_OrderNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure OrderNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_OrderNumber = "OrderNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_OrderNumber;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_OrderNumber = TypeObjectUtils::build_complete_member_detail(name_OrderNumber, member_ann_builtin_OrderNumber, ann_custom_WeightInfoOk);
            CompleteStructMember member_OrderNumber = TypeObjectUtils::build_complete_struct_member(common_OrderNumber, detail_OrderNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_OrderNumber);
        }
        {
            TypeIdentifierPair type_ids_VehicleAndVesselNumber;
            ReturnCode_t return_code_VehicleAndVesselNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_VehicleAndVesselNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_VehicleAndVesselNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VehicleAndVesselNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_VehicleAndVesselNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_VehicleAndVesselNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_VehicleAndVesselNumber = 0x0000001d;
            bool common_VehicleAndVesselNumber_ec {false};
            CommonStructMember common_VehicleAndVesselNumber {TypeObjectUtils::build_common_struct_member(member_id_VehicleAndVesselNumber, member_flags_VehicleAndVesselNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VehicleAndVesselNumber, common_VehicleAndVesselNumber_ec))};
            if (!common_VehicleAndVesselNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VehicleAndVesselNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_VehicleAndVesselNumber = "VehicleAndVesselNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VehicleAndVesselNumber;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_VehicleAndVesselNumber = TypeObjectUtils::build_complete_member_detail(name_VehicleAndVesselNumber, member_ann_builtin_VehicleAndVesselNumber, ann_custom_WeightInfoOk);
            CompleteStructMember member_VehicleAndVesselNumber = TypeObjectUtils::build_complete_struct_member(common_VehicleAndVesselNumber, detail_VehicleAndVesselNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_VehicleAndVesselNumber);
        }
        {
            TypeIdentifierPair type_ids_ReceiveCompany;
            ReturnCode_t return_code_ReceiveCompany {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ReceiveCompany =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_ReceiveCompany);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReceiveCompany)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_ReceiveCompany))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_ReceiveCompany = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ReceiveCompany = 0x0000001e;
            bool common_ReceiveCompany_ec {false};
            CommonStructMember common_ReceiveCompany {TypeObjectUtils::build_common_struct_member(member_id_ReceiveCompany, member_flags_ReceiveCompany, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ReceiveCompany, common_ReceiveCompany_ec))};
            if (!common_ReceiveCompany_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ReceiveCompany member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ReceiveCompany = "ReceiveCompany";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ReceiveCompany;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_ReceiveCompany = TypeObjectUtils::build_complete_member_detail(name_ReceiveCompany, member_ann_builtin_ReceiveCompany, ann_custom_WeightInfoOk);
            CompleteStructMember member_ReceiveCompany = TypeObjectUtils::build_complete_struct_member(common_ReceiveCompany, detail_ReceiveCompany);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_ReceiveCompany);
        }
        {
            TypeIdentifierPair type_ids_TransportCompany;
            ReturnCode_t return_code_TransportCompany {eprosima::fastdds::dds::RETCODE_OK};
            return_code_TransportCompany =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_TransportCompany);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TransportCompany)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_TransportCompany))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_TransportCompany = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_TransportCompany = 0x0000001f;
            bool common_TransportCompany_ec {false};
            CommonStructMember common_TransportCompany {TypeObjectUtils::build_common_struct_member(member_id_TransportCompany, member_flags_TransportCompany, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TransportCompany, common_TransportCompany_ec))};
            if (!common_TransportCompany_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TransportCompany member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_TransportCompany = "TransportCompany";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TransportCompany;
            ann_custom_WeightInfoOk.reset();
            CompleteMemberDetail detail_TransportCompany = TypeObjectUtils::build_complete_member_detail(name_TransportCompany, member_ann_builtin_TransportCompany, ann_custom_WeightInfoOk);
            CompleteStructMember member_TransportCompany = TypeObjectUtils::build_complete_struct_member(common_TransportCompany, detail_TransportCompany);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TransportCompany);
        }
        CompleteStructType struct_type_WeightInfoOk = TypeObjectUtils::build_complete_struct_type(struct_flags_WeightInfoOk, header_WeightInfoOk, member_seq_WeightInfoOk);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_WeightInfoOk, type_name_WeightInfoOk.to_string(), type_ids_WeightInfoOk))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::WeightInfoOk already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_WeightInfoError_type_identifier(
        TypeIdentifierPair& type_ids_WeightInfoError)
{

    ReturnCode_t return_code_WeightInfoError {eprosima::fastdds::dds::RETCODE_OK};
    return_code_WeightInfoError =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::WeightInfoError", type_ids_WeightInfoError);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightInfoError)
    {
        StructTypeFlag struct_flags_WeightInfoError = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_WeightInfoError = "WeighingSystem::WeightInfoError";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_WeightInfoError;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_WeightInfoError;
        CompleteTypeDetail detail_WeightInfoError = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_WeightInfoError, ann_custom_WeightInfoError, type_name_WeightInfoError.to_string());
        CompleteStructHeader header_WeightInfoError;
        header_WeightInfoError = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_WeightInfoError);
        CompleteStructMemberSeq member_seq_WeightInfoError;
        {
            TypeIdentifierPair type_ids_CarNumber;
            ReturnCode_t return_code_CarNumber {eprosima::fastdds::dds::RETCODE_OK};
            return_code_CarNumber =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_CarNumber);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_CarNumber)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_CarNumber))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_CarNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_CarNumber = 0x00000000;
            bool common_CarNumber_ec {false};
            CommonStructMember common_CarNumber {TypeObjectUtils::build_common_struct_member(member_id_CarNumber, member_flags_CarNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_CarNumber, common_CarNumber_ec))};
            if (!common_CarNumber_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure CarNumber member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_CarNumber = "CarNumber";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_CarNumber;
            ann_custom_WeightInfoError.reset();
            CompleteMemberDetail detail_CarNumber = TypeObjectUtils::build_complete_member_detail(name_CarNumber, member_ann_builtin_CarNumber, ann_custom_WeightInfoError);
            CompleteStructMember member_CarNumber = TypeObjectUtils::build_complete_struct_member(common_CarNumber, detail_CarNumber);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoError, member_CarNumber);
        }
        {
            TypeIdentifierPair type_ids_Warning;
            ReturnCode_t return_code_Warning {eprosima::fastdds::dds::RETCODE_OK};
            return_code_Warning =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_Warning);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Warning)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_Warning))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_Warning = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_Warning = 0x00000001;
            bool common_Warning_ec {false};
            CommonStructMember common_Warning {TypeObjectUtils::build_common_struct_member(member_id_Warning, member_flags_Warning, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Warning, common_Warning_ec))};
            if (!common_Warning_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Warning member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_Warning = "Warning";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Warning;
            ann_custom_WeightInfoError.reset();
            CompleteMemberDetail detail_Warning = TypeObjectUtils::build_complete_member_detail(name_Warning, member_ann_builtin_Warning, ann_custom_WeightInfoError);
            CompleteStructMember member_Warning = TypeObjectUtils::build_complete_struct_member(common_Warning, detail_Warning);
            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoError, member_Warning);
        }
        CompleteStructType struct_type_WeightInfoError = TypeObjectUtils::build_complete_struct_type(struct_flags_WeightInfoError, header_WeightInfoError, member_seq_WeightInfoError);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_WeightInfoError, type_name_WeightInfoError.to_string(), type_ids_WeightInfoError))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::WeightInfoError already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_BarCommandUpdate_type_identifier(
        TypeIdentifierPair& type_ids_BarCommandUpdate)
{

    ReturnCode_t return_code_BarCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_BarCommandUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::BarCommandUpdate", type_ids_BarCommandUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_BarCommandUpdate)
    {
        StructTypeFlag struct_flags_BarCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_BarCommandUpdate = "WeighingSystem::BarCommandUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_BarCommandUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_BarCommandUpdate;
        CompleteTypeDetail detail_BarCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BarCommandUpdate, ann_custom_BarCommandUpdate, type_name_BarCommandUpdate.to_string());
        CompleteStructHeader header_BarCommandUpdate;
        header_BarCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BarCommandUpdate);
        CompleteStructMemberSeq member_seq_BarCommandUpdate;
        {
            TypeIdentifierPair type_ids_FrontBarSignalUp;
            ReturnCode_t return_code_FrontBarSignalUp {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontBarSignalUp =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontBarSignalUp);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarSignalUp)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontBarSignalUp Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontBarSignalUp = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontBarSignalUp = 0x00000000;
            bool common_FrontBarSignalUp_ec {false};
            CommonStructMember common_FrontBarSignalUp {TypeObjectUtils::build_common_struct_member(member_id_FrontBarSignalUp, member_flags_FrontBarSignalUp, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarSignalUp, common_FrontBarSignalUp_ec))};
            if (!common_FrontBarSignalUp_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarSignalUp member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontBarSignalUp = "FrontBarSignalUp";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarSignalUp;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_FrontBarSignalUp = TypeObjectUtils::build_complete_member_detail(name_FrontBarSignalUp, member_ann_builtin_FrontBarSignalUp, ann_custom_BarCommandUpdate);
            CompleteStructMember member_FrontBarSignalUp = TypeObjectUtils::build_complete_struct_member(common_FrontBarSignalUp, detail_FrontBarSignalUp);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarSignalUp);
        }
        {
            TypeIdentifierPair type_ids_FrontBarSignalDown;
            ReturnCode_t return_code_FrontBarSignalDown {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontBarSignalDown =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontBarSignalDown);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarSignalDown)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontBarSignalDown Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontBarSignalDown = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontBarSignalDown = 0x00000001;
            bool common_FrontBarSignalDown_ec {false};
            CommonStructMember common_FrontBarSignalDown {TypeObjectUtils::build_common_struct_member(member_id_FrontBarSignalDown, member_flags_FrontBarSignalDown, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarSignalDown, common_FrontBarSignalDown_ec))};
            if (!common_FrontBarSignalDown_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarSignalDown member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontBarSignalDown = "FrontBarSignalDown";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarSignalDown;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_FrontBarSignalDown = TypeObjectUtils::build_complete_member_detail(name_FrontBarSignalDown, member_ann_builtin_FrontBarSignalDown, ann_custom_BarCommandUpdate);
            CompleteStructMember member_FrontBarSignalDown = TypeObjectUtils::build_complete_struct_member(common_FrontBarSignalDown, detail_FrontBarSignalDown);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarSignalDown);
        }
        {
            TypeIdentifierPair type_ids_FrontBarEnable;
            ReturnCode_t return_code_FrontBarEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontBarEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_FrontBarEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontBarEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontBarEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontBarEnable = 0x00000002;
            bool common_FrontBarEnable_ec {false};
            CommonStructMember common_FrontBarEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontBarEnable, member_flags_FrontBarEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarEnable, common_FrontBarEnable_ec))};
            if (!common_FrontBarEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontBarEnable = "FrontBarEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarEnable;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_FrontBarEnable = TypeObjectUtils::build_complete_member_detail(name_FrontBarEnable, member_ann_builtin_FrontBarEnable, ann_custom_BarCommandUpdate);
            CompleteStructMember member_FrontBarEnable = TypeObjectUtils::build_complete_struct_member(common_FrontBarEnable, detail_FrontBarEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarEnable);
        }
        {
            TypeIdentifierPair type_ids_BackBarSignalUp;
            ReturnCode_t return_code_BackBarSignalUp {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackBarSignalUp =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackBarSignalUp);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarSignalUp)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackBarSignalUp Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackBarSignalUp = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackBarSignalUp = 0x00000003;
            bool common_BackBarSignalUp_ec {false};
            CommonStructMember common_BackBarSignalUp {TypeObjectUtils::build_common_struct_member(member_id_BackBarSignalUp, member_flags_BackBarSignalUp, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarSignalUp, common_BackBarSignalUp_ec))};
            if (!common_BackBarSignalUp_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarSignalUp member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackBarSignalUp = "BackBarSignalUp";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarSignalUp;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_BackBarSignalUp = TypeObjectUtils::build_complete_member_detail(name_BackBarSignalUp, member_ann_builtin_BackBarSignalUp, ann_custom_BarCommandUpdate);
            CompleteStructMember member_BackBarSignalUp = TypeObjectUtils::build_complete_struct_member(common_BackBarSignalUp, detail_BackBarSignalUp);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarSignalUp);
        }
        {
            TypeIdentifierPair type_ids_BackBarSignalDown;
            ReturnCode_t return_code_BackBarSignalDown {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackBarSignalDown =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackBarSignalDown);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarSignalDown)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackBarSignalDown Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackBarSignalDown = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackBarSignalDown = 0x00000004;
            bool common_BackBarSignalDown_ec {false};
            CommonStructMember common_BackBarSignalDown {TypeObjectUtils::build_common_struct_member(member_id_BackBarSignalDown, member_flags_BackBarSignalDown, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarSignalDown, common_BackBarSignalDown_ec))};
            if (!common_BackBarSignalDown_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarSignalDown member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackBarSignalDown = "BackBarSignalDown";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarSignalDown;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_BackBarSignalDown = TypeObjectUtils::build_complete_member_detail(name_BackBarSignalDown, member_ann_builtin_BackBarSignalDown, ann_custom_BarCommandUpdate);
            CompleteStructMember member_BackBarSignalDown = TypeObjectUtils::build_complete_struct_member(common_BackBarSignalDown, detail_BackBarSignalDown);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarSignalDown);
        }
        {
            TypeIdentifierPair type_ids_BackBarEnable;
            ReturnCode_t return_code_BackBarEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackBarEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_BackBarEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackBarEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackBarEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackBarEnable = 0x00000005;
            bool common_BackBarEnable_ec {false};
            CommonStructMember common_BackBarEnable {TypeObjectUtils::build_common_struct_member(member_id_BackBarEnable, member_flags_BackBarEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarEnable, common_BackBarEnable_ec))};
            if (!common_BackBarEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackBarEnable = "BackBarEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarEnable;
            ann_custom_BarCommandUpdate.reset();
            CompleteMemberDetail detail_BackBarEnable = TypeObjectUtils::build_complete_member_detail(name_BackBarEnable, member_ann_builtin_BackBarEnable, ann_custom_BarCommandUpdate);
            CompleteStructMember member_BackBarEnable = TypeObjectUtils::build_complete_struct_member(common_BackBarEnable, detail_BackBarEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarEnable);
        }
        CompleteStructType struct_type_BarCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_BarCommandUpdate, header_BarCommandUpdate, member_seq_BarCommandUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_BarCommandUpdate, type_name_BarCommandUpdate.to_string(), type_ids_BarCommandUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::BarCommandUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_LightsCommandUpdate_type_identifier(
        TypeIdentifierPair& type_ids_LightsCommandUpdate)
{

    ReturnCode_t return_code_LightsCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_LightsCommandUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::LightsCommandUpdate", type_ids_LightsCommandUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LightsCommandUpdate)
    {
        StructTypeFlag struct_flags_LightsCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_LightsCommandUpdate = "WeighingSystem::LightsCommandUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LightsCommandUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LightsCommandUpdate;
        CompleteTypeDetail detail_LightsCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LightsCommandUpdate, ann_custom_LightsCommandUpdate, type_name_LightsCommandUpdate.to_string());
        CompleteStructHeader header_LightsCommandUpdate;
        header_LightsCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LightsCommandUpdate);
        CompleteStructMemberSeq member_seq_LightsCommandUpdate;
        {
            TypeIdentifierPair type_ids_FrontLEDSignal;
            ReturnCode_t return_code_FrontLEDSignal {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontLEDSignal =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontLEDSignal);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDSignal)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontLEDSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontLEDSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontLEDSignal = 0x00000000;
            bool common_FrontLEDSignal_ec {false};
            CommonStructMember common_FrontLEDSignal {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDSignal, member_flags_FrontLEDSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDSignal, common_FrontLEDSignal_ec))};
            if (!common_FrontLEDSignal_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDSignal member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontLEDSignal = "FrontLEDSignal";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDSignal;
            ann_custom_LightsCommandUpdate.reset();
            CompleteMemberDetail detail_FrontLEDSignal = TypeObjectUtils::build_complete_member_detail(name_FrontLEDSignal, member_ann_builtin_FrontLEDSignal, ann_custom_LightsCommandUpdate);
            CompleteStructMember member_FrontLEDSignal = TypeObjectUtils::build_complete_struct_member(common_FrontLEDSignal, detail_FrontLEDSignal);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_FrontLEDSignal);
        }
        {
            TypeIdentifierPair type_ids_FrontLEDEnable;
            ReturnCode_t return_code_FrontLEDEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontLEDEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_FrontLEDEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontLEDEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontLEDEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontLEDEnable = 0x00000001;
            bool common_FrontLEDEnable_ec {false};
            CommonStructMember common_FrontLEDEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDEnable, member_flags_FrontLEDEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDEnable, common_FrontLEDEnable_ec))};
            if (!common_FrontLEDEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontLEDEnable = "FrontLEDEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDEnable;
            ann_custom_LightsCommandUpdate.reset();
            CompleteMemberDetail detail_FrontLEDEnable = TypeObjectUtils::build_complete_member_detail(name_FrontLEDEnable, member_ann_builtin_FrontLEDEnable, ann_custom_LightsCommandUpdate);
            CompleteStructMember member_FrontLEDEnable = TypeObjectUtils::build_complete_struct_member(common_FrontLEDEnable, detail_FrontLEDEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_FrontLEDEnable);
        }
        {
            TypeIdentifierPair type_ids_BackLEDSignal;
            ReturnCode_t return_code_BackLEDSignal {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackLEDSignal =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackLEDSignal);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDSignal)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackLEDSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackLEDSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackLEDSignal = 0x00000002;
            bool common_BackLEDSignal_ec {false};
            CommonStructMember common_BackLEDSignal {TypeObjectUtils::build_common_struct_member(member_id_BackLEDSignal, member_flags_BackLEDSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDSignal, common_BackLEDSignal_ec))};
            if (!common_BackLEDSignal_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDSignal member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackLEDSignal = "BackLEDSignal";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDSignal;
            ann_custom_LightsCommandUpdate.reset();
            CompleteMemberDetail detail_BackLEDSignal = TypeObjectUtils::build_complete_member_detail(name_BackLEDSignal, member_ann_builtin_BackLEDSignal, ann_custom_LightsCommandUpdate);
            CompleteStructMember member_BackLEDSignal = TypeObjectUtils::build_complete_struct_member(common_BackLEDSignal, detail_BackLEDSignal);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_BackLEDSignal);
        }
        {
            TypeIdentifierPair type_ids_BackLEDEnable;
            ReturnCode_t return_code_BackLEDEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackLEDEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackLEDEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackLEDEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackLEDEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackLEDEnable = 0x00000003;
            bool common_BackLEDEnable_ec {false};
            CommonStructMember common_BackLEDEnable {TypeObjectUtils::build_common_struct_member(member_id_BackLEDEnable, member_flags_BackLEDEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDEnable, common_BackLEDEnable_ec))};
            if (!common_BackLEDEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackLEDEnable = "BackLEDEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDEnable;
            ann_custom_LightsCommandUpdate.reset();
            CompleteMemberDetail detail_BackLEDEnable = TypeObjectUtils::build_complete_member_detail(name_BackLEDEnable, member_ann_builtin_BackLEDEnable, ann_custom_LightsCommandUpdate);
            CompleteStructMember member_BackLEDEnable = TypeObjectUtils::build_complete_struct_member(common_BackLEDEnable, detail_BackLEDEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_BackLEDEnable);
        }
        CompleteStructType struct_type_LightsCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LightsCommandUpdate, header_LightsCommandUpdate, member_seq_LightsCommandUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LightsCommandUpdate, type_name_LightsCommandUpdate.to_string(), type_ids_LightsCommandUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::LightsCommandUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_InfraredCommandUpdate_type_identifier(
        TypeIdentifierPair& type_ids_InfraredCommandUpdate)
{

    ReturnCode_t return_code_InfraredCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_InfraredCommandUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::InfraredCommandUpdate", type_ids_InfraredCommandUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_InfraredCommandUpdate)
    {
        StructTypeFlag struct_flags_InfraredCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_InfraredCommandUpdate = "WeighingSystem::InfraredCommandUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_InfraredCommandUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_InfraredCommandUpdate;
        CompleteTypeDetail detail_InfraredCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_InfraredCommandUpdate, ann_custom_InfraredCommandUpdate, type_name_InfraredCommandUpdate.to_string());
        CompleteStructHeader header_InfraredCommandUpdate;
        header_InfraredCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_InfraredCommandUpdate);
        CompleteStructMemberSeq member_seq_InfraredCommandUpdate;
        {
            TypeIdentifierPair type_ids_FrontResistanceUnLock;
            ReturnCode_t return_code_FrontResistanceUnLock {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontResistanceUnLock =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontResistanceUnLock);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceUnLock)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontResistanceUnLock Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontResistanceUnLock = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontResistanceUnLock = 0x00000000;
            bool common_FrontResistanceUnLock_ec {false};
            CommonStructMember common_FrontResistanceUnLock {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceUnLock, member_flags_FrontResistanceUnLock, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceUnLock, common_FrontResistanceUnLock_ec))};
            if (!common_FrontResistanceUnLock_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceUnLock member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontResistanceUnLock = "FrontResistanceUnLock";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceUnLock;
            ann_custom_InfraredCommandUpdate.reset();
            CompleteMemberDetail detail_FrontResistanceUnLock = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceUnLock, member_ann_builtin_FrontResistanceUnLock, ann_custom_InfraredCommandUpdate);
            CompleteStructMember member_FrontResistanceUnLock = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceUnLock, detail_FrontResistanceUnLock);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_FrontResistanceUnLock);
        }
        {
            TypeIdentifierPair type_ids_FrontResistanceEnable;
            ReturnCode_t return_code_FrontResistanceEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontResistanceEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_FrontResistanceEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontResistanceEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontResistanceEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontResistanceEnable = 0x00000001;
            bool common_FrontResistanceEnable_ec {false};
            CommonStructMember common_FrontResistanceEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceEnable, member_flags_FrontResistanceEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceEnable, common_FrontResistanceEnable_ec))};
            if (!common_FrontResistanceEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontResistanceEnable = "FrontResistanceEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceEnable;
            ann_custom_InfraredCommandUpdate.reset();
            CompleteMemberDetail detail_FrontResistanceEnable = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceEnable, member_ann_builtin_FrontResistanceEnable, ann_custom_InfraredCommandUpdate);
            CompleteStructMember member_FrontResistanceEnable = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceEnable, detail_FrontResistanceEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_FrontResistanceEnable);
        }
        {
            TypeIdentifierPair type_ids_BackResistanceUnLock;
            ReturnCode_t return_code_BackResistanceUnLock {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackResistanceUnLock =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackResistanceUnLock);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceUnLock)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackResistanceUnLock Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackResistanceUnLock = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackResistanceUnLock = 0x00000002;
            bool common_BackResistanceUnLock_ec {false};
            CommonStructMember common_BackResistanceUnLock {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceUnLock, member_flags_BackResistanceUnLock, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceUnLock, common_BackResistanceUnLock_ec))};
            if (!common_BackResistanceUnLock_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceUnLock member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackResistanceUnLock = "BackResistanceUnLock";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceUnLock;
            ann_custom_InfraredCommandUpdate.reset();
            CompleteMemberDetail detail_BackResistanceUnLock = TypeObjectUtils::build_complete_member_detail(name_BackResistanceUnLock, member_ann_builtin_BackResistanceUnLock, ann_custom_InfraredCommandUpdate);
            CompleteStructMember member_BackResistanceUnLock = TypeObjectUtils::build_complete_struct_member(common_BackResistanceUnLock, detail_BackResistanceUnLock);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_BackResistanceUnLock);
        }
        {
            TypeIdentifierPair type_ids_BackResistanceEnable;
            ReturnCode_t return_code_BackResistanceEnable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackResistanceEnable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_BackResistanceEnable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceEnable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackResistanceEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackResistanceEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackResistanceEnable = 0x00000003;
            bool common_BackResistanceEnable_ec {false};
            CommonStructMember common_BackResistanceEnable {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceEnable, member_flags_BackResistanceEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceEnable, common_BackResistanceEnable_ec))};
            if (!common_BackResistanceEnable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceEnable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackResistanceEnable = "BackResistanceEnable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceEnable;
            ann_custom_InfraredCommandUpdate.reset();
            CompleteMemberDetail detail_BackResistanceEnable = TypeObjectUtils::build_complete_member_detail(name_BackResistanceEnable, member_ann_builtin_BackResistanceEnable, ann_custom_InfraredCommandUpdate);
            CompleteStructMember member_BackResistanceEnable = TypeObjectUtils::build_complete_struct_member(common_BackResistanceEnable, detail_BackResistanceEnable);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_BackResistanceEnable);
        }
        CompleteStructType struct_type_InfraredCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_InfraredCommandUpdate, header_InfraredCommandUpdate, member_seq_InfraredCommandUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_InfraredCommandUpdate, type_name_InfraredCommandUpdate.to_string(), type_ids_InfraredCommandUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::InfraredCommandUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_BarUpdate_type_identifier(
        TypeIdentifierPair& type_ids_BarUpdate)
{

    ReturnCode_t return_code_BarUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_BarUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::BarUpdate", type_ids_BarUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_BarUpdate)
    {
        StructTypeFlag struct_flags_BarUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_BarUpdate = "WeighingSystem::BarUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_BarUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_BarUpdate;
        CompleteTypeDetail detail_BarUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BarUpdate, ann_custom_BarUpdate, type_name_BarUpdate.to_string());
        CompleteStructHeader header_BarUpdate;
        header_BarUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BarUpdate);
        CompleteStructMemberSeq member_seq_BarUpdate;
        {
            TypeIdentifierPair type_ids_FrontBarState;
            ReturnCode_t return_code_FrontBarState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontBarState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontBarState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarState)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontBarState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontBarState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontBarState = 0x00000000;
            bool common_FrontBarState_ec {false};
            CommonStructMember common_FrontBarState {TypeObjectUtils::build_common_struct_member(member_id_FrontBarState, member_flags_FrontBarState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarState, common_FrontBarState_ec))};
            if (!common_FrontBarState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontBarState = "FrontBarState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarState;
            ann_custom_BarUpdate.reset();
            CompleteMemberDetail detail_FrontBarState = TypeObjectUtils::build_complete_member_detail(name_FrontBarState, member_ann_builtin_FrontBarState, ann_custom_BarUpdate);
            CompleteStructMember member_FrontBarState = TypeObjectUtils::build_complete_struct_member(common_FrontBarState, detail_FrontBarState);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarUpdate, member_FrontBarState);
        }
        {
            TypeIdentifierPair type_ids_BackBarState;
            ReturnCode_t return_code_BackBarState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackBarState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackBarState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarState)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackBarState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackBarState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackBarState = 0x00000001;
            bool common_BackBarState_ec {false};
            CommonStructMember common_BackBarState {TypeObjectUtils::build_common_struct_member(member_id_BackBarState, member_flags_BackBarState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarState, common_BackBarState_ec))};
            if (!common_BackBarState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackBarState = "BackBarState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarState;
            ann_custom_BarUpdate.reset();
            CompleteMemberDetail detail_BackBarState = TypeObjectUtils::build_complete_member_detail(name_BackBarState, member_ann_builtin_BackBarState, ann_custom_BarUpdate);
            CompleteStructMember member_BackBarState = TypeObjectUtils::build_complete_struct_member(common_BackBarState, detail_BackBarState);
            TypeObjectUtils::add_complete_struct_member(member_seq_BarUpdate, member_BackBarState);
        }
        CompleteStructType struct_type_BarUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_BarUpdate, header_BarUpdate, member_seq_BarUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_BarUpdate, type_name_BarUpdate.to_string(), type_ids_BarUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::BarUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_LightsUpdate_type_identifier(
        TypeIdentifierPair& type_ids_LightsUpdate)
{

    ReturnCode_t return_code_LightsUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_LightsUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::LightsUpdate", type_ids_LightsUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LightsUpdate)
    {
        StructTypeFlag struct_flags_LightsUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_LightsUpdate = "WeighingSystem::LightsUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LightsUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LightsUpdate;
        CompleteTypeDetail detail_LightsUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LightsUpdate, ann_custom_LightsUpdate, type_name_LightsUpdate.to_string());
        CompleteStructHeader header_LightsUpdate;
        header_LightsUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LightsUpdate);
        CompleteStructMemberSeq member_seq_LightsUpdate;
        {
            TypeIdentifierPair type_ids_FrontLEDState;
            ReturnCode_t return_code_FrontLEDState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontLEDState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontLEDState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDState)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontLEDState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontLEDState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontLEDState = 0x00000000;
            bool common_FrontLEDState_ec {false};
            CommonStructMember common_FrontLEDState {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDState, member_flags_FrontLEDState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDState, common_FrontLEDState_ec))};
            if (!common_FrontLEDState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontLEDState = "FrontLEDState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDState;
            ann_custom_LightsUpdate.reset();
            CompleteMemberDetail detail_FrontLEDState = TypeObjectUtils::build_complete_member_detail(name_FrontLEDState, member_ann_builtin_FrontLEDState, ann_custom_LightsUpdate);
            CompleteStructMember member_FrontLEDState = TypeObjectUtils::build_complete_struct_member(common_FrontLEDState, detail_FrontLEDState);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsUpdate, member_FrontLEDState);
        }
        {
            TypeIdentifierPair type_ids_BackLEDState;
            ReturnCode_t return_code_BackLEDState {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackLEDState =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackLEDState);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDState)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackLEDState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackLEDState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackLEDState = 0x00000001;
            bool common_BackLEDState_ec {false};
            CommonStructMember common_BackLEDState {TypeObjectUtils::build_common_struct_member(member_id_BackLEDState, member_flags_BackLEDState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDState, common_BackLEDState_ec))};
            if (!common_BackLEDState_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDState member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackLEDState = "BackLEDState";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDState;
            ann_custom_LightsUpdate.reset();
            CompleteMemberDetail detail_BackLEDState = TypeObjectUtils::build_complete_member_detail(name_BackLEDState, member_ann_builtin_BackLEDState, ann_custom_LightsUpdate);
            CompleteStructMember member_BackLEDState = TypeObjectUtils::build_complete_struct_member(common_BackLEDState, detail_BackLEDState);
            TypeObjectUtils::add_complete_struct_member(member_seq_LightsUpdate, member_BackLEDState);
        }
        CompleteStructType struct_type_LightsUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LightsUpdate, header_LightsUpdate, member_seq_LightsUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LightsUpdate, type_name_LightsUpdate.to_string(), type_ids_LightsUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::LightsUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_InfraredUpdate_type_identifier(
        TypeIdentifierPair& type_ids_InfraredUpdate)
{

    ReturnCode_t return_code_InfraredUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_InfraredUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::InfraredUpdate", type_ids_InfraredUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_InfraredUpdate)
    {
        StructTypeFlag struct_flags_InfraredUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_InfraredUpdate = "WeighingSystem::InfraredUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_InfraredUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_InfraredUpdate;
        CompleteTypeDetail detail_InfraredUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_InfraredUpdate, ann_custom_InfraredUpdate, type_name_InfraredUpdate.to_string());
        CompleteStructHeader header_InfraredUpdate;
        header_InfraredUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_InfraredUpdate);
        CompleteStructMemberSeq member_seq_InfraredUpdate;
        {
            TypeIdentifierPair type_ids_FrontResistanceSignal;
            ReturnCode_t return_code_FrontResistanceSignal {eprosima::fastdds::dds::RETCODE_OK};
            return_code_FrontResistanceSignal =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_FrontResistanceSignal);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceSignal)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "FrontResistanceSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_FrontResistanceSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_FrontResistanceSignal = 0x00000000;
            bool common_FrontResistanceSignal_ec {false};
            CommonStructMember common_FrontResistanceSignal {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceSignal, member_flags_FrontResistanceSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceSignal, common_FrontResistanceSignal_ec))};
            if (!common_FrontResistanceSignal_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceSignal member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_FrontResistanceSignal = "FrontResistanceSignal";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceSignal;
            ann_custom_InfraredUpdate.reset();
            CompleteMemberDetail detail_FrontResistanceSignal = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceSignal, member_ann_builtin_FrontResistanceSignal, ann_custom_InfraredUpdate);
            CompleteStructMember member_FrontResistanceSignal = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceSignal, detail_FrontResistanceSignal);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredUpdate, member_FrontResistanceSignal);
        }
        {
            TypeIdentifierPair type_ids_BackResistanceSignal;
            ReturnCode_t return_code_BackResistanceSignal {eprosima::fastdds::dds::RETCODE_OK};
            return_code_BackResistanceSignal =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_BackResistanceSignal);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceSignal)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "BackResistanceSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_BackResistanceSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_BackResistanceSignal = 0x00000001;
            bool common_BackResistanceSignal_ec {false};
            CommonStructMember common_BackResistanceSignal {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceSignal, member_flags_BackResistanceSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceSignal, common_BackResistanceSignal_ec))};
            if (!common_BackResistanceSignal_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceSignal member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_BackResistanceSignal = "BackResistanceSignal";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceSignal;
            ann_custom_InfraredUpdate.reset();
            CompleteMemberDetail detail_BackResistanceSignal = TypeObjectUtils::build_complete_member_detail(name_BackResistanceSignal, member_ann_builtin_BackResistanceSignal, ann_custom_InfraredUpdate);
            CompleteStructMember member_BackResistanceSignal = TypeObjectUtils::build_complete_struct_member(common_BackResistanceSignal, detail_BackResistanceSignal);
            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredUpdate, member_BackResistanceSignal);
        }
        CompleteStructType struct_type_InfraredUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_InfraredUpdate, header_InfraredUpdate, member_seq_InfraredUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_InfraredUpdate, type_name_InfraredUpdate.to_string(), type_ids_InfraredUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::InfraredUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_LicenseSnapUpdate_type_identifier(
        TypeIdentifierPair& type_ids_LicenseSnapUpdate)
{

    ReturnCode_t return_code_LicenseSnapUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_LicenseSnapUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::LicenseSnapUpdate", type_ids_LicenseSnapUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LicenseSnapUpdate)
    {
        StructTypeFlag struct_flags_LicenseSnapUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_LicenseSnapUpdate = "WeighingSystem::LicenseSnapUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LicenseSnapUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LicenseSnapUpdate;
        CompleteTypeDetail detail_LicenseSnapUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LicenseSnapUpdate, ann_custom_LicenseSnapUpdate, type_name_LicenseSnapUpdate.to_string());
        CompleteStructHeader header_LicenseSnapUpdate;
        header_LicenseSnapUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LicenseSnapUpdate);
        CompleteStructMemberSeq member_seq_LicenseSnapUpdate;
        {
            TypeIdentifierPair type_ids_NewTag;
            ReturnCode_t return_code_NewTag {eprosima::fastdds::dds::RETCODE_OK};
            return_code_NewTag =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_NewTag);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_NewTag)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "NewTag Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_NewTag = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_NewTag = 0x00000000;
            bool common_NewTag_ec {false};
            CommonStructMember common_NewTag {TypeObjectUtils::build_common_struct_member(member_id_NewTag, member_flags_NewTag, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_NewTag, common_NewTag_ec))};
            if (!common_NewTag_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure NewTag member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_NewTag = "NewTag";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_NewTag;
            ann_custom_LicenseSnapUpdate.reset();
            CompleteMemberDetail detail_NewTag = TypeObjectUtils::build_complete_member_detail(name_NewTag, member_ann_builtin_NewTag, ann_custom_LicenseSnapUpdate);
            CompleteStructMember member_NewTag = TypeObjectUtils::build_complete_struct_member(common_NewTag, detail_NewTag);
            TypeObjectUtils::add_complete_struct_member(member_seq_LicenseSnapUpdate, member_NewTag);
        }
        {
            TypeIdentifierPair type_ids_License;
            ReturnCode_t return_code_License {eprosima::fastdds::dds::RETCODE_OK};
            return_code_License =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_License);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_License)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_License))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_License = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_License = 0x00000001;
            bool common_License_ec {false};
            CommonStructMember common_License {TypeObjectUtils::build_common_struct_member(member_id_License, member_flags_License, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_License, common_License_ec))};
            if (!common_License_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure License member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_License = "License";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_License;
            ann_custom_LicenseSnapUpdate.reset();
            CompleteMemberDetail detail_License = TypeObjectUtils::build_complete_member_detail(name_License, member_ann_builtin_License, ann_custom_LicenseSnapUpdate);
            CompleteStructMember member_License = TypeObjectUtils::build_complete_struct_member(common_License, detail_License);
            TypeObjectUtils::add_complete_struct_member(member_seq_LicenseSnapUpdate, member_License);
        }
        CompleteStructType struct_type_LicenseSnapUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LicenseSnapUpdate, header_LicenseSnapUpdate, member_seq_LicenseSnapUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LicenseSnapUpdate, type_name_LicenseSnapUpdate.to_string(), type_ids_LicenseSnapUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::LicenseSnapUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_Voice_type_identifier(
        TypeIdentifierPair& type_ids_Voice)
{

    ReturnCode_t return_code_Voice {eprosima::fastdds::dds::RETCODE_OK};
    return_code_Voice =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::Voice", type_ids_Voice);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_Voice)
    {
        StructTypeFlag struct_flags_Voice = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_Voice = "WeighingSystem::Voice";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_Voice;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_Voice;
        CompleteTypeDetail detail_Voice = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_Voice, ann_custom_Voice, type_name_Voice.to_string());
        CompleteStructHeader header_Voice;
        header_Voice = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_Voice);
        CompleteStructMemberSeq member_seq_Voice;
        {
            TypeIdentifierPair type_ids_VoiceID;
            ReturnCode_t return_code_VoiceID {eprosima::fastdds::dds::RETCODE_OK};
            return_code_VoiceID =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_VoiceID);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VoiceID)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "VoiceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_VoiceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_VoiceID = 0x00000000;
            bool common_VoiceID_ec {false};
            CommonStructMember common_VoiceID {TypeObjectUtils::build_common_struct_member(member_id_VoiceID, member_flags_VoiceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VoiceID, common_VoiceID_ec))};
            if (!common_VoiceID_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VoiceID member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_VoiceID = "VoiceID";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VoiceID;
            ann_custom_Voice.reset();
            CompleteMemberDetail detail_VoiceID = TypeObjectUtils::build_complete_member_detail(name_VoiceID, member_ann_builtin_VoiceID, ann_custom_Voice);
            CompleteStructMember member_VoiceID = TypeObjectUtils::build_complete_struct_member(common_VoiceID, detail_VoiceID);
            TypeObjectUtils::add_complete_struct_member(member_seq_Voice, member_VoiceID);
        }
        {
            TypeIdentifierPair type_ids_VoiceContent;
            ReturnCode_t return_code_VoiceContent {eprosima::fastdds::dds::RETCODE_OK};
            return_code_VoiceContent =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_VoiceContent);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VoiceContent)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_VoiceContent))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_VoiceContent = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_VoiceContent = 0x00000001;
            bool common_VoiceContent_ec {false};
            CommonStructMember common_VoiceContent {TypeObjectUtils::build_common_struct_member(member_id_VoiceContent, member_flags_VoiceContent, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VoiceContent, common_VoiceContent_ec))};
            if (!common_VoiceContent_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VoiceContent member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_VoiceContent = "VoiceContent";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VoiceContent;
            ann_custom_Voice.reset();
            CompleteMemberDetail detail_VoiceContent = TypeObjectUtils::build_complete_member_detail(name_VoiceContent, member_ann_builtin_VoiceContent, ann_custom_Voice);
            CompleteStructMember member_VoiceContent = TypeObjectUtils::build_complete_struct_member(common_VoiceContent, detail_VoiceContent);
            TypeObjectUtils::add_complete_struct_member(member_seq_Voice, member_VoiceContent);
        }
        CompleteStructType struct_type_Voice = TypeObjectUtils::build_complete_struct_type(struct_flags_Voice, header_Voice, member_seq_Voice);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_Voice, type_name_Voice.to_string(), type_ids_Voice))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::Voice already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_SummaryUpdate_type_identifier(
        TypeIdentifierPair& type_ids_SummaryUpdate)
{

    ReturnCode_t return_code_SummaryUpdate {eprosima::fastdds::dds::RETCODE_OK};
    return_code_SummaryUpdate =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::SummaryUpdate", type_ids_SummaryUpdate);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SummaryUpdate)
    {
        StructTypeFlag struct_flags_SummaryUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_SummaryUpdate = "WeighingSystem::SummaryUpdate";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SummaryUpdate;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SummaryUpdate;
        CompleteTypeDetail detail_SummaryUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SummaryUpdate, ann_custom_SummaryUpdate, type_name_SummaryUpdate.to_string());
        CompleteStructHeader header_SummaryUpdate;
        header_SummaryUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SummaryUpdate);
        CompleteStructMemberSeq member_seq_SummaryUpdate;
        {
            TypeIdentifierPair type_ids_License;
            ReturnCode_t return_code_License {eprosima::fastdds::dds::RETCODE_OK};
            return_code_License =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_License);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_License)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_License))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_License = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_License = 0x00000000;
            bool common_License_ec {false};
            CommonStructMember common_License {TypeObjectUtils::build_common_struct_member(member_id_License, member_flags_License, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_License, common_License_ec))};
            if (!common_License_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure License member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_License = "License";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_License;
            ann_custom_SummaryUpdate.reset();
            CompleteMemberDetail detail_License = TypeObjectUtils::build_complete_member_detail(name_License, member_ann_builtin_License, ann_custom_SummaryUpdate);
            CompleteStructMember member_License = TypeObjectUtils::build_complete_struct_member(common_License, detail_License);
            TypeObjectUtils::add_complete_struct_member(member_seq_SummaryUpdate, member_License);
        }
        {
            TypeIdentifierPair type_ids_StableValue;
            ReturnCode_t return_code_StableValue {eprosima::fastdds::dds::RETCODE_OK};
            return_code_StableValue =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_StableValue);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_StableValue)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "StableValue Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_StableValue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_StableValue = 0x00000001;
            bool common_StableValue_ec {false};
            CommonStructMember common_StableValue {TypeObjectUtils::build_common_struct_member(member_id_StableValue, member_flags_StableValue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_StableValue, common_StableValue_ec))};
            if (!common_StableValue_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure StableValue member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_StableValue = "StableValue";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_StableValue;
            ann_custom_SummaryUpdate.reset();
            CompleteMemberDetail detail_StableValue = TypeObjectUtils::build_complete_member_detail(name_StableValue, member_ann_builtin_StableValue, ann_custom_SummaryUpdate);
            CompleteStructMember member_StableValue = TypeObjectUtils::build_complete_struct_member(common_StableValue, detail_StableValue);
            TypeObjectUtils::add_complete_struct_member(member_seq_SummaryUpdate, member_StableValue);
        }
        CompleteStructType struct_type_SummaryUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_SummaryUpdate, header_SummaryUpdate, member_seq_SummaryUpdate);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SummaryUpdate, type_name_SummaryUpdate.to_string(), type_ids_SummaryUpdate))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::SummaryUpdate already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_ReadCardReq_type_identifier(
        TypeIdentifierPair& type_ids_ReadCardReq)
{

    ReturnCode_t return_code_ReadCardReq {eprosima::fastdds::dds::RETCODE_OK};
    return_code_ReadCardReq =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::ReadCardReq", type_ids_ReadCardReq);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReadCardReq)
    {
        StructTypeFlag struct_flags_ReadCardReq = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_ReadCardReq = "WeighingSystem::ReadCardReq";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ReadCardReq;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ReadCardReq;
        CompleteTypeDetail detail_ReadCardReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ReadCardReq, ann_custom_ReadCardReq, type_name_ReadCardReq.to_string());
        CompleteStructHeader header_ReadCardReq;
        header_ReadCardReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ReadCardReq);
        CompleteStructMemberSeq member_seq_ReadCardReq;
        {
            TypeIdentifierPair type_ids_index;
            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
            return_code_index =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_index);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_index = 0x00000000;
            bool common_index_ec {false};
            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
            if (!common_index_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_index = "index";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
            ann_custom_ReadCardReq.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_ReadCardReq);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardReq, member_index);
        }
        {
            TypeIdentifierPair type_ids_msg;
            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
            return_code_msg =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
            {
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_sequence_byte_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    return_code_msg =
                        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                        "_byte", type_ids_msg);

                    if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
                        return;
                    }
                    bool element_identifier_anonymous_sequence_byte_unbounded_ec {false};
                    TypeIdentifier* element_identifier_anonymous_sequence_byte_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_sequence_byte_unbounded_ec))};
                    if (!element_identifier_anonymous_sequence_byte_unbounded_ec)
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
                        return;
                    }
                    EquivalenceKind equiv_kind_anonymous_sequence_byte_unbounded = EK_COMPLETE;
                    if (TK_NONE == type_ids_msg.type_identifier2()._d())
                    {
                        equiv_kind_anonymous_sequence_byte_unbounded = EK_BOTH;
                    }
                    CollectionElementFlag element_flags_anonymous_sequence_byte_unbounded = 0;
                    PlainCollectionHeader header_anonymous_sequence_byte_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_byte_unbounded, element_flags_anonymous_sequence_byte_unbounded);
                    {
                        SBound bound = 0;
                        PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_byte_unbounded, bound,
                                    eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_byte_unbounded));
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_byte_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_sequence_byte_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent element TypeIdentifier.");
                    return;
                }
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_string_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    {
                        SBound bound = 0;
                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                                "anonymous_string_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent key TypeIdentifier.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_BOTH;
                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d()) ||
                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().header().equiv_kind())))
                {
                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_COMPLETE;
                }
                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded);
                {
                    SBound bound = 0;
                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded,
                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_msg = 0x00000001;
            bool common_msg_ec {false};
            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
            if (!common_msg_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_msg = "msg";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
            ann_custom_ReadCardReq.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_ReadCardReq);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardReq, member_msg);
        }
        CompleteStructType struct_type_ReadCardReq = TypeObjectUtils::build_complete_struct_type(struct_flags_ReadCardReq, header_ReadCardReq, member_seq_ReadCardReq);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ReadCardReq, type_name_ReadCardReq.to_string(), type_ids_ReadCardReq))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::ReadCardReq already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_ReadCardRsp_type_identifier(
        TypeIdentifierPair& type_ids_ReadCardRsp)
{

    ReturnCode_t return_code_ReadCardRsp {eprosima::fastdds::dds::RETCODE_OK};
    return_code_ReadCardRsp =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::ReadCardRsp", type_ids_ReadCardRsp);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReadCardRsp)
    {
        StructTypeFlag struct_flags_ReadCardRsp = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_ReadCardRsp = "WeighingSystem::ReadCardRsp";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ReadCardRsp;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ReadCardRsp;
        CompleteTypeDetail detail_ReadCardRsp = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ReadCardRsp, ann_custom_ReadCardRsp, type_name_ReadCardRsp.to_string());
        CompleteStructHeader header_ReadCardRsp;
        header_ReadCardRsp = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ReadCardRsp);
        CompleteStructMemberSeq member_seq_ReadCardRsp;
        {
            TypeIdentifierPair type_ids_index;
            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
            return_code_index =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_index);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_index = 0x00000000;
            bool common_index_ec {false};
            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
            if (!common_index_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_index = "index";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
            ann_custom_ReadCardRsp.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_ReadCardRsp);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardRsp, member_index);
        }
        {
            TypeIdentifierPair type_ids_msg;
            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
            return_code_msg =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
            {
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_sequence_byte_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    return_code_msg =
                        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                        "_byte", type_ids_msg);

                    if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
                        return;
                    }
                    bool element_identifier_anonymous_sequence_byte_unbounded_ec {false};
                    TypeIdentifier* element_identifier_anonymous_sequence_byte_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_sequence_byte_unbounded_ec))};
                    if (!element_identifier_anonymous_sequence_byte_unbounded_ec)
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
                        return;
                    }
                    EquivalenceKind equiv_kind_anonymous_sequence_byte_unbounded = EK_COMPLETE;
                    if (TK_NONE == type_ids_msg.type_identifier2()._d())
                    {
                        equiv_kind_anonymous_sequence_byte_unbounded = EK_BOTH;
                    }
                    CollectionElementFlag element_flags_anonymous_sequence_byte_unbounded = 0;
                    PlainCollectionHeader header_anonymous_sequence_byte_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_byte_unbounded, element_flags_anonymous_sequence_byte_unbounded);
                    {
                        SBound bound = 0;
                        PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_byte_unbounded, bound,
                                    eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_byte_unbounded));
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_byte_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_sequence_byte_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent element TypeIdentifier.");
                    return;
                }
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_string_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    {
                        SBound bound = 0;
                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                                "anonymous_string_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent key TypeIdentifier.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_BOTH;
                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d()) ||
                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().header().equiv_kind())))
                {
                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_COMPLETE;
                }
                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded);
                {
                    SBound bound = 0;
                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded,
                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_msg = 0x00000001;
            bool common_msg_ec {false};
            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
            if (!common_msg_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_msg = "msg";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
            ann_custom_ReadCardRsp.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_ReadCardRsp);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardRsp, member_msg);
        }
        CompleteStructType struct_type_ReadCardRsp = TypeObjectUtils::build_complete_struct_type(struct_flags_ReadCardRsp, header_ReadCardRsp, member_seq_ReadCardRsp);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ReadCardRsp, type_name_ReadCardRsp.to_string(), type_ids_ReadCardRsp))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::ReadCardRsp already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_PrintReq_type_identifier(
        TypeIdentifierPair& type_ids_PrintReq)
{

    ReturnCode_t return_code_PrintReq {eprosima::fastdds::dds::RETCODE_OK};
    return_code_PrintReq =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::PrintReq", type_ids_PrintReq);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_PrintReq)
    {
        StructTypeFlag struct_flags_PrintReq = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_PrintReq = "WeighingSystem::PrintReq";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_PrintReq;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_PrintReq;
        CompleteTypeDetail detail_PrintReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_PrintReq, ann_custom_PrintReq, type_name_PrintReq.to_string());
        CompleteStructHeader header_PrintReq;
        header_PrintReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_PrintReq);
        CompleteStructMemberSeq member_seq_PrintReq;
        {
            TypeIdentifierPair type_ids_index;
            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
            return_code_index =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_index);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_index = 0x00000000;
            bool common_index_ec {false};
            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
            if (!common_index_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_index = "index";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
            ann_custom_PrintReq.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_PrintReq);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_PrintReq, member_index);
        }
        {
            TypeIdentifierPair type_ids_msg;
            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
            return_code_msg =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded", type_ids_msg);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
            {
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_string_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    {
                        SBound bound = 0;
                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                                "anonymous_string_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec {false};
                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec))};
                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded inconsistent element TypeIdentifier.");
                    return;
                }
                return_code_msg =
                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                    "anonymous_string_unbounded", type_ids_msg);

                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
                {
                    {
                        SBound bound = 0;
                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                                "anonymous_string_unbounded", type_ids_msg))
                        {
                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                        }
                    }
                }
                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec {false};
                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec))};
                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec)
                {
                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded inconsistent key TypeIdentifier.");
                    return;
                }
                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = EK_BOTH;
                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d()) ||
                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_ldefn().header().equiv_kind())))
                {
                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = EK_COMPLETE;
                }
                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = 0;
                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = 0;
                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded);
                {
                    SBound bound = 0;
                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded, bound,
                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded,
                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded));
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded", type_ids_msg))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_msg = 0x00000001;
            bool common_msg_ec {false};
            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
            if (!common_msg_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_msg = "msg";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
            ann_custom_PrintReq.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_PrintReq);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_PrintReq, member_msg);
        }
        CompleteStructType struct_type_PrintReq = TypeObjectUtils::build_complete_struct_type(struct_flags_PrintReq, header_PrintReq, member_seq_PrintReq);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_PrintReq, type_name_PrintReq.to_string(), type_ids_PrintReq))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::PrintReq already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_PrintRsp_type_identifier(
        TypeIdentifierPair& type_ids_PrintRsp)
{

    ReturnCode_t return_code_PrintRsp {eprosima::fastdds::dds::RETCODE_OK};
    return_code_PrintRsp =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "WeighingSystem::PrintRsp", type_ids_PrintRsp);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_PrintRsp)
    {
        StructTypeFlag struct_flags_PrintRsp = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_PrintRsp = "WeighingSystem::PrintRsp";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_PrintRsp;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_PrintRsp;
        CompleteTypeDetail detail_PrintRsp = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_PrintRsp, ann_custom_PrintRsp, type_name_PrintRsp.to_string());
        CompleteStructHeader header_PrintRsp;
        header_PrintRsp = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_PrintRsp);
        CompleteStructMemberSeq member_seq_PrintRsp;
        {
            TypeIdentifierPair type_ids_index;
            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
            return_code_index =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_uint32_t", type_ids_index);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_index = 0x00000000;
            bool common_index_ec {false};
            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
            if (!common_index_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_index = "index";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
            ann_custom_PrintRsp.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_PrintRsp);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_PrintRsp, member_index);
        }
        {
            TypeIdentifierPair type_ids_msg;
            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
            return_code_msg =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_msg);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_msg))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_msg = 0x00000001;
            bool common_msg_ec {false};
            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
            if (!common_msg_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_msg = "msg";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
            ann_custom_PrintRsp.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_PrintRsp);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_PrintRsp, member_msg);
        }
        CompleteStructType struct_type_PrintRsp = TypeObjectUtils::build_complete_struct_type(struct_flags_PrintRsp, header_PrintRsp, member_seq_PrintRsp);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_PrintRsp, type_name_PrintRsp.to_string(), type_ids_PrintRsp))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "WeighingSystem::PrintRsp already registered in TypeObjectRegistry for a different type.");
        }
    }
}

} // namespace WeighingSystem
namespace Queue {
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_QueueTrigger_type_identifier(
        TypeIdentifierPair& type_ids_QueueTrigger)
{

    ReturnCode_t return_code_QueueTrigger {eprosima::fastdds::dds::RETCODE_OK};
    return_code_QueueTrigger =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "Queue::QueueTrigger", type_ids_QueueTrigger);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_QueueTrigger)
    {
        StructTypeFlag struct_flags_QueueTrigger = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_QueueTrigger = "Queue::QueueTrigger";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_QueueTrigger;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_QueueTrigger;
        CompleteTypeDetail detail_QueueTrigger = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_QueueTrigger, ann_custom_QueueTrigger, type_name_QueueTrigger.to_string());
        CompleteStructHeader header_QueueTrigger;
        header_QueueTrigger = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_QueueTrigger);
        CompleteStructMemberSeq member_seq_QueueTrigger;
        {
            TypeIdentifierPair type_ids_message_id;
            ReturnCode_t return_code_message_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_message_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_message_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_message_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_message_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_message_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_message_id = 0x00000000;
            bool common_message_id_ec {false};
            CommonStructMember common_message_id {TypeObjectUtils::build_common_struct_member(member_id_message_id, member_flags_message_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message_id, common_message_id_ec))};
            if (!common_message_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_message_id = "message_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_message_id;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_message_id = TypeObjectUtils::build_complete_member_detail(name_message_id, member_ann_builtin_message_id, ann_custom_QueueTrigger);
            CompleteStructMember member_message_id = TypeObjectUtils::build_complete_struct_member(common_message_id, detail_message_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_message_id);
        }
        {
            TypeIdentifierPair type_ids_card_number;
            ReturnCode_t return_code_card_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_number = 0x00000001;
            bool common_card_number_ec {false};
            CommonStructMember common_card_number {TypeObjectUtils::build_common_struct_member(member_id_card_number, member_flags_card_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_number, common_card_number_ec))};
            if (!common_card_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_number = "card_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_number;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_card_number = TypeObjectUtils::build_complete_member_detail(name_card_number, member_ann_builtin_card_number, ann_custom_QueueTrigger);
            CompleteStructMember member_card_number = TypeObjectUtils::build_complete_struct_member(common_card_number, detail_card_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_card_number);
        }
        {
            TypeIdentifierPair type_ids_device_id;
            ReturnCode_t return_code_device_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_device_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_device_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_device_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_device_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_device_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_device_id = 0x00000002;
            bool common_device_id_ec {false};
            CommonStructMember common_device_id {TypeObjectUtils::build_common_struct_member(member_id_device_id, member_flags_device_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_device_id, common_device_id_ec))};
            if (!common_device_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure device_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_device_id = "device_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_device_id;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_device_id = TypeObjectUtils::build_complete_member_detail(name_device_id, member_ann_builtin_device_id, ann_custom_QueueTrigger);
            CompleteStructMember member_device_id = TypeObjectUtils::build_complete_struct_member(common_device_id, detail_device_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_device_id);
        }
        {
            TypeIdentifierPair type_ids_trigger_time;
            ReturnCode_t return_code_trigger_time {eprosima::fastdds::dds::RETCODE_OK};
            return_code_trigger_time =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_trigger_time);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_trigger_time)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_trigger_time))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_trigger_time = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_trigger_time = 0x00000003;
            bool common_trigger_time_ec {false};
            CommonStructMember common_trigger_time {TypeObjectUtils::build_common_struct_member(member_id_trigger_time, member_flags_trigger_time, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_trigger_time, common_trigger_time_ec))};
            if (!common_trigger_time_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure trigger_time member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_trigger_time = "trigger_time";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_trigger_time;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_trigger_time = TypeObjectUtils::build_complete_member_detail(name_trigger_time, member_ann_builtin_trigger_time, ann_custom_QueueTrigger);
            CompleteStructMember member_trigger_time = TypeObjectUtils::build_complete_struct_member(common_trigger_time, detail_trigger_time);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_trigger_time);
        }
        {
            TypeIdentifierPair type_ids_vehicle_number_snapshot;
            ReturnCode_t return_code_vehicle_number_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_number_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_vehicle_number_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_number_snapshot)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_vehicle_number_snapshot))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_vehicle_number_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_number_snapshot = 0x00000004;
            bool common_vehicle_number_snapshot_ec {false};
            CommonStructMember common_vehicle_number_snapshot {TypeObjectUtils::build_common_struct_member(member_id_vehicle_number_snapshot, member_flags_vehicle_number_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_number_snapshot, common_vehicle_number_snapshot_ec))};
            if (!common_vehicle_number_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_number_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_number_snapshot = "vehicle_number_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_number_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_vehicle_number_snapshot = TypeObjectUtils::build_complete_member_detail(name_vehicle_number_snapshot, member_ann_builtin_vehicle_number_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_vehicle_number_snapshot = TypeObjectUtils::build_complete_struct_member(common_vehicle_number_snapshot, detail_vehicle_number_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_vehicle_number_snapshot);
        }
        {
            TypeIdentifierPair type_ids_supplier_identity_id_snapshot;
            ReturnCode_t return_code_supplier_identity_id_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_supplier_identity_id_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_supplier_identity_id_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_supplier_identity_id_snapshot)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "supplier_identity_id_snapshot Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_supplier_identity_id_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_supplier_identity_id_snapshot = 0x00000005;
            bool common_supplier_identity_id_snapshot_ec {false};
            CommonStructMember common_supplier_identity_id_snapshot {TypeObjectUtils::build_common_struct_member(member_id_supplier_identity_id_snapshot, member_flags_supplier_identity_id_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_supplier_identity_id_snapshot, common_supplier_identity_id_snapshot_ec))};
            if (!common_supplier_identity_id_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure supplier_identity_id_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_supplier_identity_id_snapshot = "supplier_identity_id_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_supplier_identity_id_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_supplier_identity_id_snapshot = TypeObjectUtils::build_complete_member_detail(name_supplier_identity_id_snapshot, member_ann_builtin_supplier_identity_id_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_supplier_identity_id_snapshot = TypeObjectUtils::build_complete_struct_member(common_supplier_identity_id_snapshot, detail_supplier_identity_id_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_supplier_identity_id_snapshot);
        }
        {
            TypeIdentifierPair type_ids_goods_id_snapshot;
            ReturnCode_t return_code_goods_id_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_goods_id_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_goods_id_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_goods_id_snapshot)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "goods_id_snapshot Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_goods_id_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_goods_id_snapshot = 0x00000006;
            bool common_goods_id_snapshot_ec {false};
            CommonStructMember common_goods_id_snapshot {TypeObjectUtils::build_common_struct_member(member_id_goods_id_snapshot, member_flags_goods_id_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_goods_id_snapshot, common_goods_id_snapshot_ec))};
            if (!common_goods_id_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure goods_id_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_goods_id_snapshot = "goods_id_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_goods_id_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_goods_id_snapshot = TypeObjectUtils::build_complete_member_detail(name_goods_id_snapshot, member_ann_builtin_goods_id_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_goods_id_snapshot = TypeObjectUtils::build_complete_struct_member(common_goods_id_snapshot, detail_goods_id_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_goods_id_snapshot);
        }
        {
            TypeIdentifierPair type_ids_ship_net_weight_snapshot;
            ReturnCode_t return_code_ship_net_weight_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ship_net_weight_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_ship_net_weight_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ship_net_weight_snapshot)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "ship_net_weight_snapshot Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_ship_net_weight_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ship_net_weight_snapshot = 0x00000007;
            bool common_ship_net_weight_snapshot_ec {false};
            CommonStructMember common_ship_net_weight_snapshot {TypeObjectUtils::build_common_struct_member(member_id_ship_net_weight_snapshot, member_flags_ship_net_weight_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ship_net_weight_snapshot, common_ship_net_weight_snapshot_ec))};
            if (!common_ship_net_weight_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ship_net_weight_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ship_net_weight_snapshot = "ship_net_weight_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ship_net_weight_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_ship_net_weight_snapshot = TypeObjectUtils::build_complete_member_detail(name_ship_net_weight_snapshot, member_ann_builtin_ship_net_weight_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_ship_net_weight_snapshot = TypeObjectUtils::build_complete_struct_member(common_ship_net_weight_snapshot, detail_ship_net_weight_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_ship_net_weight_snapshot);
        }
        {
            TypeIdentifierPair type_ids_card_flow_no_snapshot;
            ReturnCode_t return_code_card_flow_no_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_flow_no_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_card_flow_no_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_flow_no_snapshot)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "card_flow_no_snapshot Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_card_flow_no_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_flow_no_snapshot = 0x00000008;
            bool common_card_flow_no_snapshot_ec {false};
            CommonStructMember common_card_flow_no_snapshot {TypeObjectUtils::build_common_struct_member(member_id_card_flow_no_snapshot, member_flags_card_flow_no_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_flow_no_snapshot, common_card_flow_no_snapshot_ec))};
            if (!common_card_flow_no_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_flow_no_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_flow_no_snapshot = "card_flow_no_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_flow_no_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_card_flow_no_snapshot = TypeObjectUtils::build_complete_member_detail(name_card_flow_no_snapshot, member_ann_builtin_card_flow_no_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_card_flow_no_snapshot = TypeObjectUtils::build_complete_struct_member(common_card_flow_no_snapshot, detail_card_flow_no_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_card_flow_no_snapshot);
        }
        {
            TypeIdentifierPair type_ids_card_type_snapshot;
            ReturnCode_t return_code_card_type_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_type_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_type_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_type_snapshot)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_type_snapshot))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_type_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_type_snapshot = 0x00000009;
            bool common_card_type_snapshot_ec {false};
            CommonStructMember common_card_type_snapshot {TypeObjectUtils::build_common_struct_member(member_id_card_type_snapshot, member_flags_card_type_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_type_snapshot, common_card_type_snapshot_ec))};
            if (!common_card_type_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_type_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_type_snapshot = "card_type_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_type_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_card_type_snapshot = TypeObjectUtils::build_complete_member_detail(name_card_type_snapshot, member_ann_builtin_card_type_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_card_type_snapshot = TypeObjectUtils::build_complete_struct_member(common_card_type_snapshot, detail_card_type_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_card_type_snapshot);
        }
        {
            TypeIdentifierPair type_ids_electronic_tag_snapshot;
            ReturnCode_t return_code_electronic_tag_snapshot {eprosima::fastdds::dds::RETCODE_OK};
            return_code_electronic_tag_snapshot =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_electronic_tag_snapshot);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_electronic_tag_snapshot)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_electronic_tag_snapshot))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_electronic_tag_snapshot = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_electronic_tag_snapshot = 0x0000000a;
            bool common_electronic_tag_snapshot_ec {false};
            CommonStructMember common_electronic_tag_snapshot {TypeObjectUtils::build_common_struct_member(member_id_electronic_tag_snapshot, member_flags_electronic_tag_snapshot, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_electronic_tag_snapshot, common_electronic_tag_snapshot_ec))};
            if (!common_electronic_tag_snapshot_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure electronic_tag_snapshot member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_electronic_tag_snapshot = "electronic_tag_snapshot";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_electronic_tag_snapshot;
            ann_custom_QueueTrigger.reset();
            CompleteMemberDetail detail_electronic_tag_snapshot = TypeObjectUtils::build_complete_member_detail(name_electronic_tag_snapshot, member_ann_builtin_electronic_tag_snapshot, ann_custom_QueueTrigger);
            CompleteStructMember member_electronic_tag_snapshot = TypeObjectUtils::build_complete_struct_member(common_electronic_tag_snapshot, detail_electronic_tag_snapshot);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueTrigger, member_electronic_tag_snapshot);
        }
        CompleteStructType struct_type_QueueTrigger = TypeObjectUtils::build_complete_struct_type(struct_flags_QueueTrigger, header_QueueTrigger, member_seq_QueueTrigger);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_QueueTrigger, type_name_QueueTrigger.to_string(), type_ids_QueueTrigger))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "Queue::QueueTrigger already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_QueueSuccess_type_identifier(
        TypeIdentifierPair& type_ids_QueueSuccess)
{

    ReturnCode_t return_code_QueueSuccess {eprosima::fastdds::dds::RETCODE_OK};
    return_code_QueueSuccess =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "Queue::QueueSuccess", type_ids_QueueSuccess);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_QueueSuccess)
    {
        StructTypeFlag struct_flags_QueueSuccess = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_QueueSuccess = "Queue::QueueSuccess";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_QueueSuccess;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_QueueSuccess;
        CompleteTypeDetail detail_QueueSuccess = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_QueueSuccess, ann_custom_QueueSuccess, type_name_QueueSuccess.to_string());
        CompleteStructHeader header_QueueSuccess;
        header_QueueSuccess = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_QueueSuccess);
        CompleteStructMemberSeq member_seq_QueueSuccess;
        {
            TypeIdentifierPair type_ids_message_id;
            ReturnCode_t return_code_message_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_message_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_message_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_message_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_message_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_message_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_message_id = 0x00000000;
            bool common_message_id_ec {false};
            CommonStructMember common_message_id {TypeObjectUtils::build_common_struct_member(member_id_message_id, member_flags_message_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message_id, common_message_id_ec))};
            if (!common_message_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_message_id = "message_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_message_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_message_id = TypeObjectUtils::build_complete_member_detail(name_message_id, member_ann_builtin_message_id, ann_custom_QueueSuccess);
            CompleteStructMember member_message_id = TypeObjectUtils::build_complete_struct_member(common_message_id, detail_message_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_message_id);
        }
        {
            TypeIdentifierPair type_ids_card_number;
            ReturnCode_t return_code_card_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_number = 0x00000001;
            bool common_card_number_ec {false};
            CommonStructMember common_card_number {TypeObjectUtils::build_common_struct_member(member_id_card_number, member_flags_card_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_number, common_card_number_ec))};
            if (!common_card_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_number = "card_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_number;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_card_number = TypeObjectUtils::build_complete_member_detail(name_card_number, member_ann_builtin_card_number, ann_custom_QueueSuccess);
            CompleteStructMember member_card_number = TypeObjectUtils::build_complete_struct_member(common_card_number, detail_card_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_card_number);
        }
        {
            TypeIdentifierPair type_ids_device_id;
            ReturnCode_t return_code_device_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_device_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_device_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_device_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_device_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_device_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_device_id = 0x00000002;
            bool common_device_id_ec {false};
            CommonStructMember common_device_id {TypeObjectUtils::build_common_struct_member(member_id_device_id, member_flags_device_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_device_id, common_device_id_ec))};
            if (!common_device_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure device_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_device_id = "device_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_device_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_device_id = TypeObjectUtils::build_complete_member_detail(name_device_id, member_ann_builtin_device_id, ann_custom_QueueSuccess);
            CompleteStructMember member_device_id = TypeObjectUtils::build_complete_struct_member(common_device_id, detail_device_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_device_id);
        }
        {
            TypeIdentifierPair type_ids_result_code;
            ReturnCode_t return_code_result_code {eprosima::fastdds::dds::RETCODE_OK};
            return_code_result_code =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_result_code);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_result_code)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "result_code Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_result_code = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_result_code = 0x00000003;
            bool common_result_code_ec {false};
            CommonStructMember common_result_code {TypeObjectUtils::build_common_struct_member(member_id_result_code, member_flags_result_code, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_result_code, common_result_code_ec))};
            if (!common_result_code_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure result_code member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_result_code = "result_code";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_result_code;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_result_code = TypeObjectUtils::build_complete_member_detail(name_result_code, member_ann_builtin_result_code, ann_custom_QueueSuccess);
            CompleteStructMember member_result_code = TypeObjectUtils::build_complete_struct_member(common_result_code, detail_result_code);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_result_code);
        }
        {
            TypeIdentifierPair type_ids_queue_record_id;
            ReturnCode_t return_code_queue_record_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_queue_record_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_queue_record_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_queue_record_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "queue_record_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_queue_record_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_queue_record_id = 0x00000004;
            bool common_queue_record_id_ec {false};
            CommonStructMember common_queue_record_id {TypeObjectUtils::build_common_struct_member(member_id_queue_record_id, member_flags_queue_record_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_queue_record_id, common_queue_record_id_ec))};
            if (!common_queue_record_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure queue_record_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_queue_record_id = "queue_record_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_queue_record_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_queue_record_id = TypeObjectUtils::build_complete_member_detail(name_queue_record_id, member_ann_builtin_queue_record_id, ann_custom_QueueSuccess);
            CompleteStructMember member_queue_record_id = TypeObjectUtils::build_complete_struct_member(common_queue_record_id, detail_queue_record_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_queue_record_id);
        }
        {
            TypeIdentifierPair type_ids_queue_number;
            ReturnCode_t return_code_queue_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_queue_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_queue_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_queue_number)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "queue_number Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_queue_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_queue_number = 0x00000005;
            bool common_queue_number_ec {false};
            CommonStructMember common_queue_number {TypeObjectUtils::build_common_struct_member(member_id_queue_number, member_flags_queue_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_queue_number, common_queue_number_ec))};
            if (!common_queue_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure queue_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_queue_number = "queue_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_queue_number;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_queue_number = TypeObjectUtils::build_complete_member_detail(name_queue_number, member_ann_builtin_queue_number, ann_custom_QueueSuccess);
            CompleteStructMember member_queue_number = TypeObjectUtils::build_complete_struct_member(common_queue_number, detail_queue_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_queue_number);
        }
        {
            TypeIdentifierPair type_ids_sample_machine;
            ReturnCode_t return_code_sample_machine {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sample_machine =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_sample_machine);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sample_machine)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_sample_machine))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_sample_machine = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sample_machine = 0x00000006;
            bool common_sample_machine_ec {false};
            CommonStructMember common_sample_machine {TypeObjectUtils::build_common_struct_member(member_id_sample_machine, member_flags_sample_machine, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sample_machine, common_sample_machine_ec))};
            if (!common_sample_machine_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sample_machine member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sample_machine = "sample_machine";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sample_machine;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_sample_machine = TypeObjectUtils::build_complete_member_detail(name_sample_machine, member_ann_builtin_sample_machine, ann_custom_QueueSuccess);
            CompleteStructMember member_sample_machine = TypeObjectUtils::build_complete_struct_member(common_sample_machine, detail_sample_machine);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_sample_machine);
        }
        {
            TypeIdentifierPair type_ids_queue_time;
            ReturnCode_t return_code_queue_time {eprosima::fastdds::dds::RETCODE_OK};
            return_code_queue_time =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_queue_time);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_queue_time)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_queue_time))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_queue_time = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_queue_time = 0x00000007;
            bool common_queue_time_ec {false};
            CommonStructMember common_queue_time {TypeObjectUtils::build_common_struct_member(member_id_queue_time, member_flags_queue_time, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_queue_time, common_queue_time_ec))};
            if (!common_queue_time_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure queue_time member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_queue_time = "queue_time";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_queue_time;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_queue_time = TypeObjectUtils::build_complete_member_detail(name_queue_time, member_ann_builtin_queue_time, ann_custom_QueueSuccess);
            CompleteStructMember member_queue_time = TypeObjectUtils::build_complete_struct_member(common_queue_time, detail_queue_time);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_queue_time);
        }
        {
            TypeIdentifierPair type_ids_ticket_number;
            ReturnCode_t return_code_ticket_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ticket_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_ticket_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ticket_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_ticket_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_ticket_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ticket_number = 0x00000008;
            bool common_ticket_number_ec {false};
            CommonStructMember common_ticket_number {TypeObjectUtils::build_common_struct_member(member_id_ticket_number, member_flags_ticket_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ticket_number, common_ticket_number_ec))};
            if (!common_ticket_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ticket_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ticket_number = "ticket_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ticket_number;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_ticket_number = TypeObjectUtils::build_complete_member_detail(name_ticket_number, member_ann_builtin_ticket_number, ann_custom_QueueSuccess);
            CompleteStructMember member_ticket_number = TypeObjectUtils::build_complete_struct_member(common_ticket_number, detail_ticket_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_ticket_number);
        }
        {
            TypeIdentifierPair type_ids_sample_code;
            ReturnCode_t return_code_sample_code {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sample_code =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_sample_code);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sample_code)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "sample_code Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_sample_code = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sample_code = 0x00000009;
            bool common_sample_code_ec {false};
            CommonStructMember common_sample_code {TypeObjectUtils::build_common_struct_member(member_id_sample_code, member_flags_sample_code, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sample_code, common_sample_code_ec))};
            if (!common_sample_code_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sample_code member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sample_code = "sample_code";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sample_code;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_sample_code = TypeObjectUtils::build_complete_member_detail(name_sample_code, member_ann_builtin_sample_code, ann_custom_QueueSuccess);
            CompleteStructMember member_sample_code = TypeObjectUtils::build_complete_struct_member(common_sample_code, detail_sample_code);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_sample_code);
        }
        {
            TypeIdentifierPair type_ids_vehicle_number;
            ReturnCode_t return_code_vehicle_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_vehicle_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_vehicle_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_vehicle_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_number = 0x0000000a;
            bool common_vehicle_number_ec {false};
            CommonStructMember common_vehicle_number {TypeObjectUtils::build_common_struct_member(member_id_vehicle_number, member_flags_vehicle_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_number, common_vehicle_number_ec))};
            if (!common_vehicle_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_number = "vehicle_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_number;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_vehicle_number = TypeObjectUtils::build_complete_member_detail(name_vehicle_number, member_ann_builtin_vehicle_number, ann_custom_QueueSuccess);
            CompleteStructMember member_vehicle_number = TypeObjectUtils::build_complete_struct_member(common_vehicle_number, detail_vehicle_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_vehicle_number);
        }
        {
            TypeIdentifierPair type_ids_vehicle_self_no;
            ReturnCode_t return_code_vehicle_self_no {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_self_no =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_vehicle_self_no);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_self_no)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "vehicle_self_no Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_vehicle_self_no = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_self_no = 0x0000000b;
            bool common_vehicle_self_no_ec {false};
            CommonStructMember common_vehicle_self_no {TypeObjectUtils::build_common_struct_member(member_id_vehicle_self_no, member_flags_vehicle_self_no, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_self_no, common_vehicle_self_no_ec))};
            if (!common_vehicle_self_no_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_self_no member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_self_no = "vehicle_self_no";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_self_no;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_vehicle_self_no = TypeObjectUtils::build_complete_member_detail(name_vehicle_self_no, member_ann_builtin_vehicle_self_no, ann_custom_QueueSuccess);
            CompleteStructMember member_vehicle_self_no = TypeObjectUtils::build_complete_struct_member(common_vehicle_self_no, detail_vehicle_self_no);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_vehicle_self_no);
        }
        {
            TypeIdentifierPair type_ids_vehicle_type_id;
            ReturnCode_t return_code_vehicle_type_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_type_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_vehicle_type_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_type_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "vehicle_type_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_vehicle_type_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_type_id = 0x0000000c;
            bool common_vehicle_type_id_ec {false};
            CommonStructMember common_vehicle_type_id {TypeObjectUtils::build_common_struct_member(member_id_vehicle_type_id, member_flags_vehicle_type_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_type_id, common_vehicle_type_id_ec))};
            if (!common_vehicle_type_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_type_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_type_id = "vehicle_type_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_type_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_vehicle_type_id = TypeObjectUtils::build_complete_member_detail(name_vehicle_type_id, member_ann_builtin_vehicle_type_id, ann_custom_QueueSuccess);
            CompleteStructMember member_vehicle_type_id = TypeObjectUtils::build_complete_struct_member(common_vehicle_type_id, detail_vehicle_type_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_vehicle_type_id);
        }
        {
            TypeIdentifierPair type_ids_supplier_identity_id;
            ReturnCode_t return_code_supplier_identity_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_supplier_identity_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_supplier_identity_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_supplier_identity_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "supplier_identity_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_supplier_identity_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_supplier_identity_id = 0x0000000d;
            bool common_supplier_identity_id_ec {false};
            CommonStructMember common_supplier_identity_id {TypeObjectUtils::build_common_struct_member(member_id_supplier_identity_id, member_flags_supplier_identity_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_supplier_identity_id, common_supplier_identity_id_ec))};
            if (!common_supplier_identity_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure supplier_identity_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_supplier_identity_id = "supplier_identity_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_supplier_identity_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_supplier_identity_id = TypeObjectUtils::build_complete_member_detail(name_supplier_identity_id, member_ann_builtin_supplier_identity_id, ann_custom_QueueSuccess);
            CompleteStructMember member_supplier_identity_id = TypeObjectUtils::build_complete_struct_member(common_supplier_identity_id, detail_supplier_identity_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_supplier_identity_id);
        }
        {
            TypeIdentifierPair type_ids_supplier_identity_name;
            ReturnCode_t return_code_supplier_identity_name {eprosima::fastdds::dds::RETCODE_OK};
            return_code_supplier_identity_name =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_supplier_identity_name);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_supplier_identity_name)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_supplier_identity_name))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_supplier_identity_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_supplier_identity_name = 0x0000000e;
            bool common_supplier_identity_name_ec {false};
            CommonStructMember common_supplier_identity_name {TypeObjectUtils::build_common_struct_member(member_id_supplier_identity_name, member_flags_supplier_identity_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_supplier_identity_name, common_supplier_identity_name_ec))};
            if (!common_supplier_identity_name_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure supplier_identity_name member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_supplier_identity_name = "supplier_identity_name";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_supplier_identity_name;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_supplier_identity_name = TypeObjectUtils::build_complete_member_detail(name_supplier_identity_name, member_ann_builtin_supplier_identity_name, ann_custom_QueueSuccess);
            CompleteStructMember member_supplier_identity_name = TypeObjectUtils::build_complete_struct_member(common_supplier_identity_name, detail_supplier_identity_name);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_supplier_identity_name);
        }
        {
            TypeIdentifierPair type_ids_supplier_id;
            ReturnCode_t return_code_supplier_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_supplier_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_supplier_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_supplier_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "supplier_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_supplier_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_supplier_id = 0x0000000f;
            bool common_supplier_id_ec {false};
            CommonStructMember common_supplier_id {TypeObjectUtils::build_common_struct_member(member_id_supplier_id, member_flags_supplier_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_supplier_id, common_supplier_id_ec))};
            if (!common_supplier_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure supplier_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_supplier_id = "supplier_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_supplier_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_supplier_id = TypeObjectUtils::build_complete_member_detail(name_supplier_id, member_ann_builtin_supplier_id, ann_custom_QueueSuccess);
            CompleteStructMember member_supplier_id = TypeObjectUtils::build_complete_struct_member(common_supplier_id, detail_supplier_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_supplier_id);
        }
        {
            TypeIdentifierPair type_ids_supplier_name;
            ReturnCode_t return_code_supplier_name {eprosima::fastdds::dds::RETCODE_OK};
            return_code_supplier_name =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_supplier_name);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_supplier_name)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_supplier_name))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_supplier_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_supplier_name = 0x00000010;
            bool common_supplier_name_ec {false};
            CommonStructMember common_supplier_name {TypeObjectUtils::build_common_struct_member(member_id_supplier_name, member_flags_supplier_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_supplier_name, common_supplier_name_ec))};
            if (!common_supplier_name_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure supplier_name member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_supplier_name = "supplier_name";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_supplier_name;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_supplier_name = TypeObjectUtils::build_complete_member_detail(name_supplier_name, member_ann_builtin_supplier_name, ann_custom_QueueSuccess);
            CompleteStructMember member_supplier_name = TypeObjectUtils::build_complete_struct_member(common_supplier_name, detail_supplier_name);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_supplier_name);
        }
        {
            TypeIdentifierPair type_ids_goods_id;
            ReturnCode_t return_code_goods_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_goods_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_goods_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_goods_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "goods_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_goods_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_goods_id = 0x00000011;
            bool common_goods_id_ec {false};
            CommonStructMember common_goods_id {TypeObjectUtils::build_common_struct_member(member_id_goods_id, member_flags_goods_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_goods_id, common_goods_id_ec))};
            if (!common_goods_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure goods_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_goods_id = "goods_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_goods_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_goods_id = TypeObjectUtils::build_complete_member_detail(name_goods_id, member_ann_builtin_goods_id, ann_custom_QueueSuccess);
            CompleteStructMember member_goods_id = TypeObjectUtils::build_complete_struct_member(common_goods_id, detail_goods_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_goods_id);
        }
        {
            TypeIdentifierPair type_ids_goods_name;
            ReturnCode_t return_code_goods_name {eprosima::fastdds::dds::RETCODE_OK};
            return_code_goods_name =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_goods_name);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_goods_name)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_goods_name))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_goods_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_goods_name = 0x00000012;
            bool common_goods_name_ec {false};
            CommonStructMember common_goods_name {TypeObjectUtils::build_common_struct_member(member_id_goods_name, member_flags_goods_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_goods_name, common_goods_name_ec))};
            if (!common_goods_name_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure goods_name member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_goods_name = "goods_name";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_goods_name;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_goods_name = TypeObjectUtils::build_complete_member_detail(name_goods_name, member_ann_builtin_goods_name, ann_custom_QueueSuccess);
            CompleteStructMember member_goods_name = TypeObjectUtils::build_complete_struct_member(common_goods_name, detail_goods_name);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_goods_name);
        }
        {
            TypeIdentifierPair type_ids_unit_id;
            ReturnCode_t return_code_unit_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_unit_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_unit_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_unit_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "unit_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_unit_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_unit_id = 0x00000013;
            bool common_unit_id_ec {false};
            CommonStructMember common_unit_id {TypeObjectUtils::build_common_struct_member(member_id_unit_id, member_flags_unit_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unit_id, common_unit_id_ec))};
            if (!common_unit_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unit_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_unit_id = "unit_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_unit_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_unit_id = TypeObjectUtils::build_complete_member_detail(name_unit_id, member_ann_builtin_unit_id, ann_custom_QueueSuccess);
            CompleteStructMember member_unit_id = TypeObjectUtils::build_complete_struct_member(common_unit_id, detail_unit_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_unit_id);
        }
        {
            TypeIdentifierPair type_ids_transport_company_id;
            ReturnCode_t return_code_transport_company_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_transport_company_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_transport_company_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_transport_company_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "transport_company_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_transport_company_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_transport_company_id = 0x00000014;
            bool common_transport_company_id_ec {false};
            CommonStructMember common_transport_company_id {TypeObjectUtils::build_common_struct_member(member_id_transport_company_id, member_flags_transport_company_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_transport_company_id, common_transport_company_id_ec))};
            if (!common_transport_company_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure transport_company_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_transport_company_id = "transport_company_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_transport_company_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_transport_company_id = TypeObjectUtils::build_complete_member_detail(name_transport_company_id, member_ann_builtin_transport_company_id, ann_custom_QueueSuccess);
            CompleteStructMember member_transport_company_id = TypeObjectUtils::build_complete_struct_member(common_transport_company_id, detail_transport_company_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_transport_company_id);
        }
        {
            TypeIdentifierPair type_ids_sample_type;
            ReturnCode_t return_code_sample_type {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sample_type =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_sample_type);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sample_type)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "sample_type Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_sample_type = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sample_type = 0x00000015;
            bool common_sample_type_ec {false};
            CommonStructMember common_sample_type {TypeObjectUtils::build_common_struct_member(member_id_sample_type, member_flags_sample_type, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sample_type, common_sample_type_ec))};
            if (!common_sample_type_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sample_type member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sample_type = "sample_type";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sample_type;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_sample_type = TypeObjectUtils::build_complete_member_detail(name_sample_type, member_ann_builtin_sample_type, ann_custom_QueueSuccess);
            CompleteStructMember member_sample_type = TypeObjectUtils::build_complete_struct_member(common_sample_type, detail_sample_type);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_sample_type);
        }
        {
            TypeIdentifierPair type_ids_unloading_point_name;
            ReturnCode_t return_code_unloading_point_name {eprosima::fastdds::dds::RETCODE_OK};
            return_code_unloading_point_name =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_unloading_point_name);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_unloading_point_name)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_unloading_point_name))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_unloading_point_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_unloading_point_name = 0x00000016;
            bool common_unloading_point_name_ec {false};
            CommonStructMember common_unloading_point_name {TypeObjectUtils::build_common_struct_member(member_id_unloading_point_name, member_flags_unloading_point_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unloading_point_name, common_unloading_point_name_ec))};
            if (!common_unloading_point_name_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unloading_point_name member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_unloading_point_name = "unloading_point_name";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_unloading_point_name;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_unloading_point_name = TypeObjectUtils::build_complete_member_detail(name_unloading_point_name, member_ann_builtin_unloading_point_name, ann_custom_QueueSuccess);
            CompleteStructMember member_unloading_point_name = TypeObjectUtils::build_complete_struct_member(common_unloading_point_name, detail_unloading_point_name);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_unloading_point_name);
        }
        {
            TypeIdentifierPair type_ids_ship_gross_weight;
            ReturnCode_t return_code_ship_gross_weight {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ship_gross_weight =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_ship_gross_weight);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ship_gross_weight)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "ship_gross_weight Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_ship_gross_weight = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ship_gross_weight = 0x00000017;
            bool common_ship_gross_weight_ec {false};
            CommonStructMember common_ship_gross_weight {TypeObjectUtils::build_common_struct_member(member_id_ship_gross_weight, member_flags_ship_gross_weight, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ship_gross_weight, common_ship_gross_weight_ec))};
            if (!common_ship_gross_weight_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ship_gross_weight member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ship_gross_weight = "ship_gross_weight";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ship_gross_weight;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_ship_gross_weight = TypeObjectUtils::build_complete_member_detail(name_ship_gross_weight, member_ann_builtin_ship_gross_weight, ann_custom_QueueSuccess);
            CompleteStructMember member_ship_gross_weight = TypeObjectUtils::build_complete_struct_member(common_ship_gross_weight, detail_ship_gross_weight);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_ship_gross_weight);
        }
        {
            TypeIdentifierPair type_ids_ship_tare_weight;
            ReturnCode_t return_code_ship_tare_weight {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ship_tare_weight =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_ship_tare_weight);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ship_tare_weight)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "ship_tare_weight Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_ship_tare_weight = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ship_tare_weight = 0x00000018;
            bool common_ship_tare_weight_ec {false};
            CommonStructMember common_ship_tare_weight {TypeObjectUtils::build_common_struct_member(member_id_ship_tare_weight, member_flags_ship_tare_weight, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ship_tare_weight, common_ship_tare_weight_ec))};
            if (!common_ship_tare_weight_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ship_tare_weight member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ship_tare_weight = "ship_tare_weight";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ship_tare_weight;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_ship_tare_weight = TypeObjectUtils::build_complete_member_detail(name_ship_tare_weight, member_ann_builtin_ship_tare_weight, ann_custom_QueueSuccess);
            CompleteStructMember member_ship_tare_weight = TypeObjectUtils::build_complete_struct_member(common_ship_tare_weight, detail_ship_tare_weight);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_ship_tare_weight);
        }
        {
            TypeIdentifierPair type_ids_ship_net_weight;
            ReturnCode_t return_code_ship_net_weight {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ship_net_weight =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_float", type_ids_ship_net_weight);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ship_net_weight)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "ship_net_weight Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_ship_net_weight = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ship_net_weight = 0x00000019;
            bool common_ship_net_weight_ec {false};
            CommonStructMember common_ship_net_weight {TypeObjectUtils::build_common_struct_member(member_id_ship_net_weight, member_flags_ship_net_weight, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ship_net_weight, common_ship_net_weight_ec))};
            if (!common_ship_net_weight_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ship_net_weight member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ship_net_weight = "ship_net_weight";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ship_net_weight;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_ship_net_weight = TypeObjectUtils::build_complete_member_detail(name_ship_net_weight, member_ann_builtin_ship_net_weight, ann_custom_QueueSuccess);
            CompleteStructMember member_ship_net_weight = TypeObjectUtils::build_complete_struct_member(common_ship_net_weight, detail_ship_net_weight);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_ship_net_weight);
        }
        {
            TypeIdentifierPair type_ids_sample_machine_id;
            ReturnCode_t return_code_sample_machine_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sample_machine_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_sample_machine_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sample_machine_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "sample_machine_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_sample_machine_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sample_machine_id = 0x0000001a;
            bool common_sample_machine_id_ec {false};
            CommonStructMember common_sample_machine_id {TypeObjectUtils::build_common_struct_member(member_id_sample_machine_id, member_flags_sample_machine_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sample_machine_id, common_sample_machine_id_ec))};
            if (!common_sample_machine_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sample_machine_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sample_machine_id = "sample_machine_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sample_machine_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_sample_machine_id = TypeObjectUtils::build_complete_member_detail(name_sample_machine_id, member_ann_builtin_sample_machine_id, ann_custom_QueueSuccess);
            CompleteStructMember member_sample_machine_id = TypeObjectUtils::build_complete_struct_member(common_sample_machine_id, detail_sample_machine_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_sample_machine_id);
        }
        {
            TypeIdentifierPair type_ids_vehicle_lane;
            ReturnCode_t return_code_vehicle_lane {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_lane =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_vehicle_lane);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_lane)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_vehicle_lane))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_vehicle_lane = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_lane = 0x0000001b;
            bool common_vehicle_lane_ec {false};
            CommonStructMember common_vehicle_lane {TypeObjectUtils::build_common_struct_member(member_id_vehicle_lane, member_flags_vehicle_lane, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_lane, common_vehicle_lane_ec))};
            if (!common_vehicle_lane_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_lane member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_lane = "vehicle_lane";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_lane;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_vehicle_lane = TypeObjectUtils::build_complete_member_detail(name_vehicle_lane, member_ann_builtin_vehicle_lane, ann_custom_QueueSuccess);
            CompleteStructMember member_vehicle_lane = TypeObjectUtils::build_complete_struct_member(common_vehicle_lane, detail_vehicle_lane);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_vehicle_lane);
        }
        {
            TypeIdentifierPair type_ids_vehicle_lane_id;
            ReturnCode_t return_code_vehicle_lane_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_lane_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_vehicle_lane_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_lane_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "vehicle_lane_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_vehicle_lane_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_lane_id = 0x0000001c;
            bool common_vehicle_lane_id_ec {false};
            CommonStructMember common_vehicle_lane_id {TypeObjectUtils::build_common_struct_member(member_id_vehicle_lane_id, member_flags_vehicle_lane_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_lane_id, common_vehicle_lane_id_ec))};
            if (!common_vehicle_lane_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_lane_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_lane_id = "vehicle_lane_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_lane_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_vehicle_lane_id = TypeObjectUtils::build_complete_member_detail(name_vehicle_lane_id, member_ann_builtin_vehicle_lane_id, ann_custom_QueueSuccess);
            CompleteStructMember member_vehicle_lane_id = TypeObjectUtils::build_complete_struct_member(common_vehicle_lane_id, detail_vehicle_lane_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_vehicle_lane_id);
        }
        {
            TypeIdentifierPair type_ids_strategy_desc;
            ReturnCode_t return_code_strategy_desc {eprosima::fastdds::dds::RETCODE_OK};
            return_code_strategy_desc =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_strategy_desc);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_strategy_desc)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_strategy_desc))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_strategy_desc = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_strategy_desc = 0x0000001d;
            bool common_strategy_desc_ec {false};
            CommonStructMember common_strategy_desc {TypeObjectUtils::build_common_struct_member(member_id_strategy_desc, member_flags_strategy_desc, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_strategy_desc, common_strategy_desc_ec))};
            if (!common_strategy_desc_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure strategy_desc member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_strategy_desc = "strategy_desc";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_strategy_desc;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_strategy_desc = TypeObjectUtils::build_complete_member_detail(name_strategy_desc, member_ann_builtin_strategy_desc, ann_custom_QueueSuccess);
            CompleteStructMember member_strategy_desc = TypeObjectUtils::build_complete_struct_member(common_strategy_desc, detail_strategy_desc);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_strategy_desc);
        }
        {
            TypeIdentifierPair type_ids_committed_at;
            ReturnCode_t return_code_committed_at {eprosima::fastdds::dds::RETCODE_OK};
            return_code_committed_at =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_committed_at);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_committed_at)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_committed_at))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_committed_at = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_committed_at = 0x0000001e;
            bool common_committed_at_ec {false};
            CommonStructMember common_committed_at {TypeObjectUtils::build_common_struct_member(member_id_committed_at, member_flags_committed_at, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_committed_at, common_committed_at_ec))};
            if (!common_committed_at_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure committed_at member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_committed_at = "committed_at";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_committed_at;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_committed_at = TypeObjectUtils::build_complete_member_detail(name_committed_at, member_ann_builtin_committed_at, ann_custom_QueueSuccess);
            CompleteStructMember member_committed_at = TypeObjectUtils::build_complete_struct_member(common_committed_at, detail_committed_at);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_committed_at);
        }
        {
            TypeIdentifierPair type_ids_display_text;
            ReturnCode_t return_code_display_text {eprosima::fastdds::dds::RETCODE_OK};
            return_code_display_text =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_display_text);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_display_text)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_display_text))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_display_text = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_display_text = 0x0000001f;
            bool common_display_text_ec {false};
            CommonStructMember common_display_text {TypeObjectUtils::build_common_struct_member(member_id_display_text, member_flags_display_text, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_display_text, common_display_text_ec))};
            if (!common_display_text_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure display_text member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_display_text = "display_text";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_display_text;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_display_text = TypeObjectUtils::build_complete_member_detail(name_display_text, member_ann_builtin_display_text, ann_custom_QueueSuccess);
            CompleteStructMember member_display_text = TypeObjectUtils::build_complete_struct_member(common_display_text, detail_display_text);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_display_text);
        }
        {
            TypeIdentifierPair type_ids_print_content;
            ReturnCode_t return_code_print_content {eprosima::fastdds::dds::RETCODE_OK};
            return_code_print_content =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_print_content);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_print_content)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_print_content))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_print_content = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_print_content = 0x00000020;
            bool common_print_content_ec {false};
            CommonStructMember common_print_content {TypeObjectUtils::build_common_struct_member(member_id_print_content, member_flags_print_content, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_print_content, common_print_content_ec))};
            if (!common_print_content_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure print_content member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_print_content = "print_content";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_print_content;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_print_content = TypeObjectUtils::build_complete_member_detail(name_print_content, member_ann_builtin_print_content, ann_custom_QueueSuccess);
            CompleteStructMember member_print_content = TypeObjectUtils::build_complete_struct_member(common_print_content, detail_print_content);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_print_content);
        }
        {
            TypeIdentifierPair type_ids_print_required;
            ReturnCode_t return_code_print_required {eprosima::fastdds::dds::RETCODE_OK};
            return_code_print_required =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_print_required);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_print_required)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "print_required Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_print_required = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_print_required = 0x00000021;
            bool common_print_required_ec {false};
            CommonStructMember common_print_required {TypeObjectUtils::build_common_struct_member(member_id_print_required, member_flags_print_required, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_print_required, common_print_required_ec))};
            if (!common_print_required_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure print_required member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_print_required = "print_required";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_print_required;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_print_required = TypeObjectUtils::build_complete_member_detail(name_print_required, member_ann_builtin_print_required, ann_custom_QueueSuccess);
            CompleteStructMember member_print_required = TypeObjectUtils::build_complete_struct_member(common_print_required, detail_print_required);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_print_required);
        }
        {
            TypeIdentifierPair type_ids_print_count;
            ReturnCode_t return_code_print_count {eprosima::fastdds::dds::RETCODE_OK};
            return_code_print_count =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_print_count);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_print_count)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "print_count Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_print_count = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_print_count = 0x00000022;
            bool common_print_count_ec {false};
            CommonStructMember common_print_count {TypeObjectUtils::build_common_struct_member(member_id_print_count, member_flags_print_count, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_print_count, common_print_count_ec))};
            if (!common_print_count_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure print_count member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_print_count = "print_count";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_print_count;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_print_count = TypeObjectUtils::build_complete_member_detail(name_print_count, member_ann_builtin_print_count, ann_custom_QueueSuccess);
            CompleteStructMember member_print_count = TypeObjectUtils::build_complete_struct_member(common_print_count, detail_print_count);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_print_count);
        }
        {
            TypeIdentifierPair type_ids_voice_id;
            ReturnCode_t return_code_voice_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_voice_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_voice_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_voice_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "voice_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_voice_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_voice_id = 0x00000023;
            bool common_voice_id_ec {false};
            CommonStructMember common_voice_id {TypeObjectUtils::build_common_struct_member(member_id_voice_id, member_flags_voice_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_voice_id, common_voice_id_ec))};
            if (!common_voice_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure voice_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_voice_id = "voice_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_voice_id;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_voice_id = TypeObjectUtils::build_complete_member_detail(name_voice_id, member_ann_builtin_voice_id, ann_custom_QueueSuccess);
            CompleteStructMember member_voice_id = TypeObjectUtils::build_complete_struct_member(common_voice_id, detail_voice_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_voice_id);
        }
        {
            TypeIdentifierPair type_ids_voice_text;
            ReturnCode_t return_code_voice_text {eprosima::fastdds::dds::RETCODE_OK};
            return_code_voice_text =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_voice_text);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_voice_text)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_voice_text))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_voice_text = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_voice_text = 0x00000024;
            bool common_voice_text_ec {false};
            CommonStructMember common_voice_text {TypeObjectUtils::build_common_struct_member(member_id_voice_text, member_flags_voice_text, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_voice_text, common_voice_text_ec))};
            if (!common_voice_text_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure voice_text member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_voice_text = "voice_text";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_voice_text;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_voice_text = TypeObjectUtils::build_complete_member_detail(name_voice_text, member_ann_builtin_voice_text, ann_custom_QueueSuccess);
            CompleteStructMember member_voice_text = TypeObjectUtils::build_complete_struct_member(common_voice_text, detail_voice_text);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_voice_text);
        }
        {
            TypeIdentifierPair type_ids_is_reprint;
            ReturnCode_t return_code_is_reprint {eprosima::fastdds::dds::RETCODE_OK};
            return_code_is_reprint =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_is_reprint);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_is_reprint)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "is_reprint Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_is_reprint = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_is_reprint = 0x00000025;
            bool common_is_reprint_ec {false};
            CommonStructMember common_is_reprint {TypeObjectUtils::build_common_struct_member(member_id_is_reprint, member_flags_is_reprint, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_is_reprint, common_is_reprint_ec))};
            if (!common_is_reprint_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure is_reprint member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_is_reprint = "is_reprint";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_is_reprint;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_is_reprint = TypeObjectUtils::build_complete_member_detail(name_is_reprint, member_ann_builtin_is_reprint, ann_custom_QueueSuccess);
            CompleteStructMember member_is_reprint = TypeObjectUtils::build_complete_struct_member(common_is_reprint, detail_is_reprint);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_is_reprint);
        }
        {
            TypeIdentifierPair type_ids_physical_card_state;
            ReturnCode_t return_code_physical_card_state {eprosima::fastdds::dds::RETCODE_OK};
            return_code_physical_card_state =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_physical_card_state);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_physical_card_state)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_physical_card_state))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_physical_card_state = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_physical_card_state = 0x00000026;
            bool common_physical_card_state_ec {false};
            CommonStructMember common_physical_card_state {TypeObjectUtils::build_common_struct_member(member_id_physical_card_state, member_flags_physical_card_state, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_physical_card_state, common_physical_card_state_ec))};
            if (!common_physical_card_state_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure physical_card_state member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_physical_card_state = "physical_card_state";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_physical_card_state;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_physical_card_state = TypeObjectUtils::build_complete_member_detail(name_physical_card_state, member_ann_builtin_physical_card_state, ann_custom_QueueSuccess);
            CompleteStructMember member_physical_card_state = TypeObjectUtils::build_complete_struct_member(common_physical_card_state, detail_physical_card_state);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_physical_card_state);
        }
        {
            TypeIdentifierPair type_ids_card_write_status;
            ReturnCode_t return_code_card_write_status {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_write_status =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_write_status);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_write_status)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_write_status))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_write_status = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_write_status = 0x00000027;
            bool common_card_write_status_ec {false};
            CommonStructMember common_card_write_status {TypeObjectUtils::build_common_struct_member(member_id_card_write_status, member_flags_card_write_status, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_write_status, common_card_write_status_ec))};
            if (!common_card_write_status_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_write_status member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_write_status = "card_write_status";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_write_status;
            ann_custom_QueueSuccess.reset();
            CompleteMemberDetail detail_card_write_status = TypeObjectUtils::build_complete_member_detail(name_card_write_status, member_ann_builtin_card_write_status, ann_custom_QueueSuccess);
            CompleteStructMember member_card_write_status = TypeObjectUtils::build_complete_struct_member(common_card_write_status, detail_card_write_status);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueSuccess, member_card_write_status);
        }
        CompleteStructType struct_type_QueueSuccess = TypeObjectUtils::build_complete_struct_type(struct_flags_QueueSuccess, header_QueueSuccess, member_seq_QueueSuccess);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_QueueSuccess, type_name_QueueSuccess.to_string(), type_ids_QueueSuccess))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "Queue::QueueSuccess already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_QueueFailure_type_identifier(
        TypeIdentifierPair& type_ids_QueueFailure)
{

    ReturnCode_t return_code_QueueFailure {eprosima::fastdds::dds::RETCODE_OK};
    return_code_QueueFailure =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "Queue::QueueFailure", type_ids_QueueFailure);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_QueueFailure)
    {
        StructTypeFlag struct_flags_QueueFailure = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_QueueFailure = "Queue::QueueFailure";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_QueueFailure;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_QueueFailure;
        CompleteTypeDetail detail_QueueFailure = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_QueueFailure, ann_custom_QueueFailure, type_name_QueueFailure.to_string());
        CompleteStructHeader header_QueueFailure;
        header_QueueFailure = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_QueueFailure);
        CompleteStructMemberSeq member_seq_QueueFailure;
        {
            TypeIdentifierPair type_ids_message_id;
            ReturnCode_t return_code_message_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_message_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_message_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_message_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_message_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_message_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_message_id = 0x00000000;
            bool common_message_id_ec {false};
            CommonStructMember common_message_id {TypeObjectUtils::build_common_struct_member(member_id_message_id, member_flags_message_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message_id, common_message_id_ec))};
            if (!common_message_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_message_id = "message_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_message_id;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_message_id = TypeObjectUtils::build_complete_member_detail(name_message_id, member_ann_builtin_message_id, ann_custom_QueueFailure);
            CompleteStructMember member_message_id = TypeObjectUtils::build_complete_struct_member(common_message_id, detail_message_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_message_id);
        }
        {
            TypeIdentifierPair type_ids_card_number;
            ReturnCode_t return_code_card_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_number = 0x00000001;
            bool common_card_number_ec {false};
            CommonStructMember common_card_number {TypeObjectUtils::build_common_struct_member(member_id_card_number, member_flags_card_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_number, common_card_number_ec))};
            if (!common_card_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_number = "card_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_number;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_card_number = TypeObjectUtils::build_complete_member_detail(name_card_number, member_ann_builtin_card_number, ann_custom_QueueFailure);
            CompleteStructMember member_card_number = TypeObjectUtils::build_complete_struct_member(common_card_number, detail_card_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_card_number);
        }
        {
            TypeIdentifierPair type_ids_device_id;
            ReturnCode_t return_code_device_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_device_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_device_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_device_id)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_device_id))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_device_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_device_id = 0x00000002;
            bool common_device_id_ec {false};
            CommonStructMember common_device_id {TypeObjectUtils::build_common_struct_member(member_id_device_id, member_flags_device_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_device_id, common_device_id_ec))};
            if (!common_device_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure device_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_device_id = "device_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_device_id;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_device_id = TypeObjectUtils::build_complete_member_detail(name_device_id, member_ann_builtin_device_id, ann_custom_QueueFailure);
            CompleteStructMember member_device_id = TypeObjectUtils::build_complete_struct_member(common_device_id, detail_device_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_device_id);
        }
        {
            TypeIdentifierPair type_ids_error_code;
            ReturnCode_t return_code_error_code {eprosima::fastdds::dds::RETCODE_OK};
            return_code_error_code =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_error_code);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_error_code)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_error_code))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_error_code = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_error_code = 0x00000003;
            bool common_error_code_ec {false};
            CommonStructMember common_error_code {TypeObjectUtils::build_common_struct_member(member_id_error_code, member_flags_error_code, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_error_code, common_error_code_ec))};
            if (!common_error_code_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure error_code member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_error_code = "error_code";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_error_code;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_error_code = TypeObjectUtils::build_complete_member_detail(name_error_code, member_ann_builtin_error_code, ann_custom_QueueFailure);
            CompleteStructMember member_error_code = TypeObjectUtils::build_complete_struct_member(common_error_code, detail_error_code);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_error_code);
        }
        {
            TypeIdentifierPair type_ids_failed_step;
            ReturnCode_t return_code_failed_step {eprosima::fastdds::dds::RETCODE_OK};
            return_code_failed_step =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_failed_step);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_failed_step)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_failed_step))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_failed_step = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_failed_step = 0x00000004;
            bool common_failed_step_ec {false};
            CommonStructMember common_failed_step {TypeObjectUtils::build_common_struct_member(member_id_failed_step, member_flags_failed_step, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_failed_step, common_failed_step_ec))};
            if (!common_failed_step_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure failed_step member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_failed_step = "failed_step";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_failed_step;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_failed_step = TypeObjectUtils::build_complete_member_detail(name_failed_step, member_ann_builtin_failed_step, ann_custom_QueueFailure);
            CompleteStructMember member_failed_step = TypeObjectUtils::build_complete_struct_member(common_failed_step, detail_failed_step);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_failed_step);
        }
        {
            TypeIdentifierPair type_ids_message;
            ReturnCode_t return_code_message {eprosima::fastdds::dds::RETCODE_OK};
            return_code_message =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_message);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_message)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_message))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_message = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_message = 0x00000005;
            bool common_message_ec {false};
            CommonStructMember common_message {TypeObjectUtils::build_common_struct_member(member_id_message, member_flags_message, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message, common_message_ec))};
            if (!common_message_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_message = "message";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_message;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_message = TypeObjectUtils::build_complete_member_detail(name_message, member_ann_builtin_message, ann_custom_QueueFailure);
            CompleteStructMember member_message = TypeObjectUtils::build_complete_struct_member(common_message, detail_message);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_message);
        }
        {
            TypeIdentifierPair type_ids_vehicle_number;
            ReturnCode_t return_code_vehicle_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_vehicle_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_vehicle_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_vehicle_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_vehicle_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_vehicle_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_vehicle_number = 0x00000006;
            bool common_vehicle_number_ec {false};
            CommonStructMember common_vehicle_number {TypeObjectUtils::build_common_struct_member(member_id_vehicle_number, member_flags_vehicle_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_vehicle_number, common_vehicle_number_ec))};
            if (!common_vehicle_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure vehicle_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_vehicle_number = "vehicle_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_vehicle_number;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_vehicle_number = TypeObjectUtils::build_complete_member_detail(name_vehicle_number, member_ann_builtin_vehicle_number, ann_custom_QueueFailure);
            CompleteStructMember member_vehicle_number = TypeObjectUtils::build_complete_struct_member(common_vehicle_number, detail_vehicle_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_vehicle_number);
        }
        {
            TypeIdentifierPair type_ids_queue_record_id;
            ReturnCode_t return_code_queue_record_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_queue_record_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_queue_record_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_queue_record_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "queue_record_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_queue_record_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_queue_record_id = 0x00000007;
            bool common_queue_record_id_ec {false};
            CommonStructMember common_queue_record_id {TypeObjectUtils::build_common_struct_member(member_id_queue_record_id, member_flags_queue_record_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_queue_record_id, common_queue_record_id_ec))};
            if (!common_queue_record_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure queue_record_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_queue_record_id = "queue_record_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_queue_record_id;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_queue_record_id = TypeObjectUtils::build_complete_member_detail(name_queue_record_id, member_ann_builtin_queue_record_id, ann_custom_QueueFailure);
            CompleteStructMember member_queue_record_id = TypeObjectUtils::build_complete_struct_member(common_queue_record_id, detail_queue_record_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_queue_record_id);
        }
        {
            TypeIdentifierPair type_ids_queue_number;
            ReturnCode_t return_code_queue_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_queue_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_queue_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_queue_number)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "queue_number Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_queue_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_queue_number = 0x00000008;
            bool common_queue_number_ec {false};
            CommonStructMember common_queue_number {TypeObjectUtils::build_common_struct_member(member_id_queue_number, member_flags_queue_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_queue_number, common_queue_number_ec))};
            if (!common_queue_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure queue_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_queue_number = "queue_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_queue_number;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_queue_number = TypeObjectUtils::build_complete_member_detail(name_queue_number, member_ann_builtin_queue_number, ann_custom_QueueFailure);
            CompleteStructMember member_queue_number = TypeObjectUtils::build_complete_struct_member(common_queue_number, detail_queue_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_queue_number);
        }
        {
            TypeIdentifierPair type_ids_sample_machine;
            ReturnCode_t return_code_sample_machine {eprosima::fastdds::dds::RETCODE_OK};
            return_code_sample_machine =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_sample_machine);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_sample_machine)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_sample_machine))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_sample_machine = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_sample_machine = 0x00000009;
            bool common_sample_machine_ec {false};
            CommonStructMember common_sample_machine {TypeObjectUtils::build_common_struct_member(member_id_sample_machine, member_flags_sample_machine, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sample_machine, common_sample_machine_ec))};
            if (!common_sample_machine_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sample_machine member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_sample_machine = "sample_machine";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_sample_machine;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_sample_machine = TypeObjectUtils::build_complete_member_detail(name_sample_machine, member_ann_builtin_sample_machine, ann_custom_QueueFailure);
            CompleteStructMember member_sample_machine = TypeObjectUtils::build_complete_struct_member(common_sample_machine, detail_sample_machine);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_sample_machine);
        }
        {
            TypeIdentifierPair type_ids_ticket_number;
            ReturnCode_t return_code_ticket_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_ticket_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_ticket_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ticket_number)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_ticket_number))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_ticket_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_ticket_number = 0x0000000a;
            bool common_ticket_number_ec {false};
            CommonStructMember common_ticket_number {TypeObjectUtils::build_common_struct_member(member_id_ticket_number, member_flags_ticket_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ticket_number, common_ticket_number_ec))};
            if (!common_ticket_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ticket_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_ticket_number = "ticket_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ticket_number;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_ticket_number = TypeObjectUtils::build_complete_member_detail(name_ticket_number, member_ann_builtin_ticket_number, ann_custom_QueueFailure);
            CompleteStructMember member_ticket_number = TypeObjectUtils::build_complete_struct_member(common_ticket_number, detail_ticket_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_ticket_number);
        }
        {
            TypeIdentifierPair type_ids_existing_queue_record_id;
            ReturnCode_t return_code_existing_queue_record_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_existing_queue_record_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_existing_queue_record_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_existing_queue_record_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "existing_queue_record_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_existing_queue_record_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_existing_queue_record_id = 0x0000000b;
            bool common_existing_queue_record_id_ec {false};
            CommonStructMember common_existing_queue_record_id {TypeObjectUtils::build_common_struct_member(member_id_existing_queue_record_id, member_flags_existing_queue_record_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_existing_queue_record_id, common_existing_queue_record_id_ec))};
            if (!common_existing_queue_record_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure existing_queue_record_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_existing_queue_record_id = "existing_queue_record_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_existing_queue_record_id;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_existing_queue_record_id = TypeObjectUtils::build_complete_member_detail(name_existing_queue_record_id, member_ann_builtin_existing_queue_record_id, ann_custom_QueueFailure);
            CompleteStructMember member_existing_queue_record_id = TypeObjectUtils::build_complete_struct_member(common_existing_queue_record_id, detail_existing_queue_record_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_existing_queue_record_id);
        }
        {
            TypeIdentifierPair type_ids_existing_queue_number;
            ReturnCode_t return_code_existing_queue_number {eprosima::fastdds::dds::RETCODE_OK};
            return_code_existing_queue_number =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_existing_queue_number);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_existing_queue_number)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "existing_queue_number Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_existing_queue_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_existing_queue_number = 0x0000000c;
            bool common_existing_queue_number_ec {false};
            CommonStructMember common_existing_queue_number {TypeObjectUtils::build_common_struct_member(member_id_existing_queue_number, member_flags_existing_queue_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_existing_queue_number, common_existing_queue_number_ec))};
            if (!common_existing_queue_number_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure existing_queue_number member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_existing_queue_number = "existing_queue_number";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_existing_queue_number;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_existing_queue_number = TypeObjectUtils::build_complete_member_detail(name_existing_queue_number, member_ann_builtin_existing_queue_number, ann_custom_QueueFailure);
            CompleteStructMember member_existing_queue_number = TypeObjectUtils::build_complete_struct_member(common_existing_queue_number, detail_existing_queue_number);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_existing_queue_number);
        }
        {
            TypeIdentifierPair type_ids_existing_sample_machine;
            ReturnCode_t return_code_existing_sample_machine {eprosima::fastdds::dds::RETCODE_OK};
            return_code_existing_sample_machine =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_existing_sample_machine);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_existing_sample_machine)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_existing_sample_machine))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_existing_sample_machine = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_existing_sample_machine = 0x0000000d;
            bool common_existing_sample_machine_ec {false};
            CommonStructMember common_existing_sample_machine {TypeObjectUtils::build_common_struct_member(member_id_existing_sample_machine, member_flags_existing_sample_machine, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_existing_sample_machine, common_existing_sample_machine_ec))};
            if (!common_existing_sample_machine_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure existing_sample_machine member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_existing_sample_machine = "existing_sample_machine";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_existing_sample_machine;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_existing_sample_machine = TypeObjectUtils::build_complete_member_detail(name_existing_sample_machine, member_ann_builtin_existing_sample_machine, ann_custom_QueueFailure);
            CompleteStructMember member_existing_sample_machine = TypeObjectUtils::build_complete_struct_member(common_existing_sample_machine, detail_existing_sample_machine);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_existing_sample_machine);
        }
        {
            TypeIdentifierPair type_ids_cache_state;
            ReturnCode_t return_code_cache_state {eprosima::fastdds::dds::RETCODE_OK};
            return_code_cache_state =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_cache_state);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_cache_state)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_cache_state))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_cache_state = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_cache_state = 0x0000000e;
            bool common_cache_state_ec {false};
            CommonStructMember common_cache_state {TypeObjectUtils::build_common_struct_member(member_id_cache_state, member_flags_cache_state, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_cache_state, common_cache_state_ec))};
            if (!common_cache_state_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure cache_state member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_cache_state = "cache_state";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_cache_state;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_cache_state = TypeObjectUtils::build_complete_member_detail(name_cache_state, member_ann_builtin_cache_state, ann_custom_QueueFailure);
            CompleteStructMember member_cache_state = TypeObjectUtils::build_complete_struct_member(common_cache_state, detail_cache_state);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_cache_state);
        }
        {
            TypeIdentifierPair type_ids_database_state;
            ReturnCode_t return_code_database_state {eprosima::fastdds::dds::RETCODE_OK};
            return_code_database_state =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_database_state);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_database_state)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_database_state))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_database_state = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_database_state = 0x0000000f;
            bool common_database_state_ec {false};
            CommonStructMember common_database_state {TypeObjectUtils::build_common_struct_member(member_id_database_state, member_flags_database_state, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_database_state, common_database_state_ec))};
            if (!common_database_state_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure database_state member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_database_state = "database_state";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_database_state;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_database_state = TypeObjectUtils::build_complete_member_detail(name_database_state, member_ann_builtin_database_state, ann_custom_QueueFailure);
            CompleteStructMember member_database_state = TypeObjectUtils::build_complete_struct_member(common_database_state, detail_database_state);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_database_state);
        }
        {
            TypeIdentifierPair type_ids_physical_card_state;
            ReturnCode_t return_code_physical_card_state {eprosima::fastdds::dds::RETCODE_OK};
            return_code_physical_card_state =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_physical_card_state);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_physical_card_state)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_physical_card_state))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_physical_card_state = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_physical_card_state = 0x00000010;
            bool common_physical_card_state_ec {false};
            CommonStructMember common_physical_card_state {TypeObjectUtils::build_common_struct_member(member_id_physical_card_state, member_flags_physical_card_state, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_physical_card_state, common_physical_card_state_ec))};
            if (!common_physical_card_state_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure physical_card_state member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_physical_card_state = "physical_card_state";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_physical_card_state;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_physical_card_state = TypeObjectUtils::build_complete_member_detail(name_physical_card_state, member_ann_builtin_physical_card_state, ann_custom_QueueFailure);
            CompleteStructMember member_physical_card_state = TypeObjectUtils::build_complete_struct_member(common_physical_card_state, detail_physical_card_state);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_physical_card_state);
        }
        {
            TypeIdentifierPair type_ids_retryable;
            ReturnCode_t return_code_retryable {eprosima::fastdds::dds::RETCODE_OK};
            return_code_retryable =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_bool", type_ids_retryable);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_retryable)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "retryable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_retryable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_retryable = 0x00000011;
            bool common_retryable_ec {false};
            CommonStructMember common_retryable {TypeObjectUtils::build_common_struct_member(member_id_retryable, member_flags_retryable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_retryable, common_retryable_ec))};
            if (!common_retryable_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure retryable member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_retryable = "retryable";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_retryable;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_retryable = TypeObjectUtils::build_complete_member_detail(name_retryable, member_ann_builtin_retryable, ann_custom_QueueFailure);
            CompleteStructMember member_retryable = TypeObjectUtils::build_complete_struct_member(common_retryable, detail_retryable);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_retryable);
        }
        {
            TypeIdentifierPair type_ids_retry_after_ms;
            ReturnCode_t return_code_retry_after_ms {eprosima::fastdds::dds::RETCODE_OK};
            return_code_retry_after_ms =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_retry_after_ms);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_retry_after_ms)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "retry_after_ms Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_retry_after_ms = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_retry_after_ms = 0x00000012;
            bool common_retry_after_ms_ec {false};
            CommonStructMember common_retry_after_ms {TypeObjectUtils::build_common_struct_member(member_id_retry_after_ms, member_flags_retry_after_ms, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_retry_after_ms, common_retry_after_ms_ec))};
            if (!common_retry_after_ms_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure retry_after_ms member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_retry_after_ms = "retry_after_ms";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_retry_after_ms;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_retry_after_ms = TypeObjectUtils::build_complete_member_detail(name_retry_after_ms, member_ann_builtin_retry_after_ms, ann_custom_QueueFailure);
            CompleteStructMember member_retry_after_ms = TypeObjectUtils::build_complete_struct_member(common_retry_after_ms, detail_retry_after_ms);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_retry_after_ms);
        }
        {
            TypeIdentifierPair type_ids_voice_id;
            ReturnCode_t return_code_voice_id {eprosima::fastdds::dds::RETCODE_OK};
            return_code_voice_id =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "_int32_t", type_ids_voice_id);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_voice_id)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                        "voice_id Structure member TypeIdentifier unknown to TypeObjectRegistry.");
                return;
            }
            StructMemberFlag member_flags_voice_id = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_voice_id = 0x00000013;
            bool common_voice_id_ec {false};
            CommonStructMember common_voice_id {TypeObjectUtils::build_common_struct_member(member_id_voice_id, member_flags_voice_id, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_voice_id, common_voice_id_ec))};
            if (!common_voice_id_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure voice_id member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_voice_id = "voice_id";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_voice_id;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_voice_id = TypeObjectUtils::build_complete_member_detail(name_voice_id, member_ann_builtin_voice_id, ann_custom_QueueFailure);
            CompleteStructMember member_voice_id = TypeObjectUtils::build_complete_struct_member(common_voice_id, detail_voice_id);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_voice_id);
        }
        {
            TypeIdentifierPair type_ids_voice_text;
            ReturnCode_t return_code_voice_text {eprosima::fastdds::dds::RETCODE_OK};
            return_code_voice_text =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_voice_text);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_voice_text)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_voice_text))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_voice_text = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_voice_text = 0x00000014;
            bool common_voice_text_ec {false};
            CommonStructMember common_voice_text {TypeObjectUtils::build_common_struct_member(member_id_voice_text, member_flags_voice_text, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_voice_text, common_voice_text_ec))};
            if (!common_voice_text_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure voice_text member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_voice_text = "voice_text";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_voice_text;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_voice_text = TypeObjectUtils::build_complete_member_detail(name_voice_text, member_ann_builtin_voice_text, ann_custom_QueueFailure);
            CompleteStructMember member_voice_text = TypeObjectUtils::build_complete_struct_member(common_voice_text, detail_voice_text);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_voice_text);
        }
        {
            TypeIdentifierPair type_ids_card_write_status;
            ReturnCode_t return_code_card_write_status {eprosima::fastdds::dds::RETCODE_OK};
            return_code_card_write_status =
                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
                "anonymous_string_unbounded", type_ids_card_write_status);

            if (eprosima::fastdds::dds::RETCODE_OK != return_code_card_write_status)
            {
                {
                    SBound bound = 0;
                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
                            "anonymous_string_unbounded", type_ids_card_write_status))
                    {
                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
                    }
                }
            }
            StructMemberFlag member_flags_card_write_status = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
                    false, false, false, false);
            MemberId member_id_card_write_status = 0x00000015;
            bool common_card_write_status_ec {false};
            CommonStructMember common_card_write_status {TypeObjectUtils::build_common_struct_member(member_id_card_write_status, member_flags_card_write_status, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_card_write_status, common_card_write_status_ec))};
            if (!common_card_write_status_ec)
            {
                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure card_write_status member TypeIdentifier inconsistent.");
                return;
            }
            MemberName name_card_write_status = "card_write_status";
            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_card_write_status;
            ann_custom_QueueFailure.reset();
            CompleteMemberDetail detail_card_write_status = TypeObjectUtils::build_complete_member_detail(name_card_write_status, member_ann_builtin_card_write_status, ann_custom_QueueFailure);
            CompleteStructMember member_card_write_status = TypeObjectUtils::build_complete_struct_member(common_card_write_status, detail_card_write_status);
            TypeObjectUtils::add_complete_struct_member(member_seq_QueueFailure, member_card_write_status);
        }
        CompleteStructType struct_type_QueueFailure = TypeObjectUtils::build_complete_struct_type(struct_flags_QueueFailure, header_QueueFailure, member_seq_QueueFailure);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_QueueFailure, type_name_QueueFailure.to_string(), type_ids_QueueFailure))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "Queue::QueueFailure already registered in TypeObjectRegistry for a different type.");
        }
    }
}

} // namespace Queue