// 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 SystemTypeObjectSupport.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 "SystemTypeObjectSupport.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 "System.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);
        }
        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.");
        }
    }
}

} // namespace WeighingSystem
namespace InternalSystem {
// 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(
        "InternalSystem::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 = "InternalSystem::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,
                    "InternalSystem::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(
        "InternalSystem::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 = "InternalSystem::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,
                    "InternalSystem::PrintRsp already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_IoCtrlReq_type_identifier(
        TypeIdentifierPair& type_ids_IoCtrlReq)
{

    ReturnCode_t return_code_IoCtrlReq {eprosima::fastdds::dds::RETCODE_OK};
    return_code_IoCtrlReq =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "InternalSystem::IoCtrlReq", type_ids_IoCtrlReq);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_IoCtrlReq)
    {
        StructTypeFlag struct_flags_IoCtrlReq = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_IoCtrlReq = "InternalSystem::IoCtrlReq";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_IoCtrlReq;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_IoCtrlReq;
        CompleteTypeDetail detail_IoCtrlReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_IoCtrlReq, ann_custom_IoCtrlReq, type_name_IoCtrlReq.to_string());
        CompleteStructHeader header_IoCtrlReq;
        header_IoCtrlReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_IoCtrlReq);
        CompleteStructMemberSeq member_seq_IoCtrlReq;
        {
            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_IoCtrlReq.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_IoCtrlReq);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_IoCtrlReq, 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_IoCtrlReq.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_IoCtrlReq);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_IoCtrlReq, member_msg);
        }
        CompleteStructType struct_type_IoCtrlReq = TypeObjectUtils::build_complete_struct_type(struct_flags_IoCtrlReq, header_IoCtrlReq, member_seq_IoCtrlReq);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_IoCtrlReq, type_name_IoCtrlReq.to_string(), type_ids_IoCtrlReq))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "InternalSystem::IoCtrlReq already registered in TypeObjectRegistry for a different type.");
        }
    }
}
// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
void register_IoCtrlRsp_type_identifier(
        TypeIdentifierPair& type_ids_IoCtrlRsp)
{

    ReturnCode_t return_code_IoCtrlRsp {eprosima::fastdds::dds::RETCODE_OK};
    return_code_IoCtrlRsp =
        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
        "InternalSystem::IoCtrlRsp", type_ids_IoCtrlRsp);
    if (eprosima::fastdds::dds::RETCODE_OK != return_code_IoCtrlRsp)
    {
        StructTypeFlag struct_flags_IoCtrlRsp = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
                false, false);
        QualifiedTypeName type_name_IoCtrlRsp = "InternalSystem::IoCtrlRsp";
        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_IoCtrlRsp;
        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_IoCtrlRsp;
        CompleteTypeDetail detail_IoCtrlRsp = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_IoCtrlRsp, ann_custom_IoCtrlRsp, type_name_IoCtrlRsp.to_string());
        CompleteStructHeader header_IoCtrlRsp;
        header_IoCtrlRsp = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_IoCtrlRsp);
        CompleteStructMemberSeq member_seq_IoCtrlRsp;
        {
            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_IoCtrlRsp.reset();
            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_IoCtrlRsp);
            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
            TypeObjectUtils::add_complete_struct_member(member_seq_IoCtrlRsp, 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_IoCtrlRsp.reset();
            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_IoCtrlRsp);
            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
            TypeObjectUtils::add_complete_struct_member(member_seq_IoCtrlRsp, member_msg);
        }
        CompleteStructType struct_type_IoCtrlRsp = TypeObjectUtils::build_complete_struct_type(struct_flags_IoCtrlRsp, header_IoCtrlRsp, member_seq_IoCtrlRsp);
        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
                TypeObjectUtils::build_and_register_struct_type_object(struct_type_IoCtrlRsp, type_name_IoCtrlRsp.to_string(), type_ids_IoCtrlRsp))
        {
            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
                    "InternalSystem::IoCtrlRsp already registered in TypeObjectRegistry for a different type.");
        }
    }
}

} // namespace InternalSystem