1. 新建打印程序。

CMakeLists.txt

@@ -41,6 +41,20 @@ target_link_libraries(Demo fastcdr fastdds
         System_lib
         )
 
+# Print Application.
+add_executable(Print
+                print/main.cxx
+                print/Publisher.cxx
+                print/Subscriber.cxx
+                print/MsgHandler.cxx
+                common/SerialMsgHandler.cxx
+                lib/strcode.cpp
+              )
+target_include_directories(Print PRIVATE print)
+target_link_libraries(Print fastcdr fastdds
+        System_lib
+        )
+
 # Weigh Application.
 add_executable(Weigh
                 weigh/main.cxx

lib/System.hpp

@@ -52,6 +52,346 @@
 #define SYSTEM_DllAPI
 #endif // _WIN32
 
+/*!
+ * @brief This class represents the structure PrintReq defined by the user in the IDL file.
+ * @ingroup System
+ */
+class PrintReq
+{
+public:
+
+    /*!
+     * @brief Default constructor.
+     */
+    eProsima_user_DllExport PrintReq()
+    {
+    }
+
+    /*!
+     * @brief Default destructor.
+     */
+    eProsima_user_DllExport ~PrintReq()
+    {
+    }
+
+    /*!
+     * @brief Copy constructor.
+     * @param x Reference to the object PrintReq that will be copied.
+     */
+    eProsima_user_DllExport PrintReq(
+            const PrintReq& x)
+    {
+                    m_index = x.m_index;
+
+                    m_msg = x.m_msg;
+
+    }
+
+    /*!
+     * @brief Move constructor.
+     * @param x Reference to the object PrintReq that will be copied.
+     */
+    eProsima_user_DllExport PrintReq(
+            PrintReq&& x) noexcept
+    {
+        m_index = x.m_index;
+        m_msg = std::move(x.m_msg);
+    }
+
+    /*!
+     * @brief Copy assignment.
+     * @param x Reference to the object PrintReq that will be copied.
+     */
+    eProsima_user_DllExport PrintReq& operator =(
+            const PrintReq& x)
+    {
+
+                    m_index = x.m_index;
+
+                    m_msg = x.m_msg;
+
+        return *this;
+    }
+
+    /*!
+     * @brief Move assignment.
+     * @param x Reference to the object PrintReq that will be copied.
+     */
+    eProsima_user_DllExport PrintReq& operator =(
+            PrintReq&& x) noexcept
+    {
+
+        m_index = x.m_index;
+        m_msg = std::move(x.m_msg);
+        return *this;
+    }
+
+    /*!
+     * @brief Comparison operator.
+     * @param x PrintReq object to compare.
+     */
+    eProsima_user_DllExport bool operator ==(
+            const PrintReq& x) const
+    {
+        return (m_index == x.m_index &&
+           m_msg == x.m_msg);
+    }
+
+    /*!
+     * @brief Comparison operator.
+     * @param x PrintReq object to compare.
+     */
+    eProsima_user_DllExport bool operator !=(
+            const PrintReq& x) const
+    {
+        return !(*this == x);
+    }
+
+    /*!
+     * @brief This function sets a value in member index
+     * @param _index New value for member index
+     */
+    eProsima_user_DllExport void index(
+            uint32_t _index)
+    {
+        m_index = _index;
+    }
+
+    /*!
+     * @brief This function returns the value of member index
+     * @return Value of member index
+     */
+    eProsima_user_DllExport uint32_t index() const
+    {
+        return m_index;
+    }
+
+    /*!
+     * @brief This function returns a reference to member index
+     * @return Reference to member index
+     */
+    eProsima_user_DllExport uint32_t& index()
+    {
+        return m_index;
+    }
+
+
+    /*!
+     * @brief This function copies the value in member msg
+     * @param _msg New value to be copied in member msg
+     */
+    eProsima_user_DllExport void msg(
+            const std::map<std::string, std::string>& _msg)
+    {
+        m_msg = _msg;
+    }
+
+    /*!
+     * @brief This function moves the value in member msg
+     * @param _msg New value to be moved in member msg
+     */
+    eProsima_user_DllExport void msg(
+            std::map<std::string, std::string>&& _msg)
+    {
+        m_msg = std::move(_msg);
+    }
+
+    /*!
+     * @brief This function returns a constant reference to member msg
+     * @return Constant reference to member msg
+     */
+    eProsima_user_DllExport const std::map<std::string, std::string>& msg() const
+    {
+        return m_msg;
+    }
+
+    /*!
+     * @brief This function returns a reference to member msg
+     * @return Reference to member msg
+     */
+    eProsima_user_DllExport std::map<std::string, std::string>& msg()
+    {
+        return m_msg;
+    }
+
+
+
+private:
+
+    uint32_t m_index{0};
+    std::map<std::string, std::string> m_msg;
+
+};
+/*!
+ * @brief This class represents the structure PrintRsp defined by the user in the IDL file.
+ * @ingroup System
+ */
+class PrintRsp
+{
+public:
+
+    /*!
+     * @brief Default constructor.
+     */
+    eProsima_user_DllExport PrintRsp()
+    {
+    }
+
+    /*!
+     * @brief Default destructor.
+     */
+    eProsima_user_DllExport ~PrintRsp()
+    {
+    }
+
+    /*!
+     * @brief Copy constructor.
+     * @param x Reference to the object PrintRsp that will be copied.
+     */
+    eProsima_user_DllExport PrintRsp(
+            const PrintRsp& x)
+    {
+                    m_index = x.m_index;
+
+                    m_msg = x.m_msg;
+
+    }
+
+    /*!
+     * @brief Move constructor.
+     * @param x Reference to the object PrintRsp that will be copied.
+     */
+    eProsima_user_DllExport PrintRsp(
+            PrintRsp&& x) noexcept
+    {
+        m_index = x.m_index;
+        m_msg = std::move(x.m_msg);
+    }
+
+    /*!
+     * @brief Copy assignment.
+     * @param x Reference to the object PrintRsp that will be copied.
+     */
+    eProsima_user_DllExport PrintRsp& operator =(
+            const PrintRsp& x)
+    {
+
+                    m_index = x.m_index;
+
+                    m_msg = x.m_msg;
+
+        return *this;
+    }
+
+    /*!
+     * @brief Move assignment.
+     * @param x Reference to the object PrintRsp that will be copied.
+     */
+    eProsima_user_DllExport PrintRsp& operator =(
+            PrintRsp&& x) noexcept
+    {
+
+        m_index = x.m_index;
+        m_msg = std::move(x.m_msg);
+        return *this;
+    }
+
+    /*!
+     * @brief Comparison operator.
+     * @param x PrintRsp object to compare.
+     */
+    eProsima_user_DllExport bool operator ==(
+            const PrintRsp& x) const
+    {
+        return (m_index == x.m_index &&
+           m_msg == x.m_msg);
+    }
+
+    /*!
+     * @brief Comparison operator.
+     * @param x PrintRsp object to compare.
+     */
+    eProsima_user_DllExport bool operator !=(
+            const PrintRsp& x) const
+    {
+        return !(*this == x);
+    }
+
+    /*!
+     * @brief This function sets a value in member index
+     * @param _index New value for member index
+     */
+    eProsima_user_DllExport void index(
+            uint32_t _index)
+    {
+        m_index = _index;
+    }
+
+    /*!
+     * @brief This function returns the value of member index
+     * @return Value of member index
+     */
+    eProsima_user_DllExport uint32_t index() const
+    {
+        return m_index;
+    }
+
+    /*!
+     * @brief This function returns a reference to member index
+     * @return Reference to member index
+     */
+    eProsima_user_DllExport uint32_t& index()
+    {
+        return m_index;
+    }
+
+
+    /*!
+     * @brief This function copies the value in member msg
+     * @param _msg New value to be copied in member msg
+     */
+    eProsima_user_DllExport void msg(
+            const std::string& _msg)
+    {
+        m_msg = _msg;
+    }
+
+    /*!
+     * @brief This function moves the value in member msg
+     * @param _msg New value to be moved in member msg
+     */
+    eProsima_user_DllExport void msg(
+            std::string&& _msg)
+    {
+        m_msg = std::move(_msg);
+    }
+
+    /*!
+     * @brief This function returns a constant reference to member msg
+     * @return Constant reference to member msg
+     */
+    eProsima_user_DllExport const std::string& msg() const
+    {
+        return m_msg;
+    }
+
+    /*!
+     * @brief This function returns a reference to member msg
+     * @return Reference to member msg
+     */
+    eProsima_user_DllExport std::string& msg()
+    {
+        return m_msg;
+    }
+
+
+
+private:
+
+    uint32_t m_index{0};
+    std::string m_msg;
+
+};
 /*!
  * @brief This class represents the structure WeighReq defined by the user in the IDL file.
  * @ingroup System

lib/System.idl

@@ -1,4 +1,16 @@
 @extensibility(APPENDABLE)
+struct PrintReq
+{
+    unsigned long index;
+    map<string, string> msg;
+};
+
+struct PrintRsp
+{
+    unsigned long index;
+    string msg;
+};
+
 struct WeighReq
 {
     unsigned long index;

lib/SystemCdrAux.hpp

@@ -24,9 +24,15 @@
 
 #include "System.hpp"
 
+constexpr uint32_t PrintReq_max_cdr_typesize {16UL};
+constexpr uint32_t PrintReq_max_key_cdr_typesize {0UL};
+
 constexpr uint32_t WeighReq_max_cdr_typesize {16UL};
 constexpr uint32_t WeighReq_max_key_cdr_typesize {0UL};
 
+constexpr uint32_t PrintRsp_max_cdr_typesize {268UL};
+constexpr uint32_t PrintRsp_max_key_cdr_typesize {0UL};
+
 constexpr uint32_t WeighRsp_max_cdr_typesize {16UL};
 constexpr uint32_t WeighRsp_max_key_cdr_typesize {0UL};
 
@@ -37,6 +43,14 @@ namespace fastcdr {
 class Cdr;
 class CdrSizeCalculator;
 
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintReq& data);
+
+eProsima_user_DllExport void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintRsp& data);
+
 eProsima_user_DllExport void serialize_key(
         eprosima::fastcdr::Cdr& scdr,
         const WeighReq& data);

lib/SystemCdrAux.ipp

@@ -34,6 +34,184 @@ using namespace eprosima::fastcdr::exception;
 namespace eprosima {
 namespace fastcdr {
 
+template<>
+eProsima_user_DllExport size_t calculate_serialized_size(
+        eprosima::fastcdr::CdrSizeCalculator& calculator,
+        const PrintReq& data,
+        size_t& current_alignment)
+{
+    static_cast<void>(data);
+
+    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
+    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
+                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
+                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
+                                current_alignment)};
+
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
+                data.index(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
+                data.msg(), current_alignment);
+
+
+    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
+
+    return calculated_size;
+}
+
+template<>
+eProsima_user_DllExport void serialize(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintReq& data)
+{
+    eprosima::fastcdr::Cdr::state current_state(scdr);
+    scdr.begin_serialize_type(current_state,
+            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
+            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
+
+    scdr
+        << eprosima::fastcdr::MemberId(0) << data.index()
+        << eprosima::fastcdr::MemberId(1) << data.msg()
+;
+    scdr.end_serialize_type(current_state);
+}
+
+template<>
+eProsima_user_DllExport void deserialize(
+        eprosima::fastcdr::Cdr& cdr,
+        PrintReq& data)
+{
+    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
+            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
+            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
+            {
+                bool ret_value = true;
+                switch (mid.id)
+                {
+                                        case 0:
+                                                dcdr >> data.index();
+                                            break;
+
+                                        case 1:
+                                                dcdr >> data.msg();
+                                            break;
+
+                    default:
+                        ret_value = false;
+                        break;
+                }
+                return ret_value;
+            });
+}
+
+void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintReq& data)
+{
+
+    static_cast<void>(scdr);
+    static_cast<void>(data);
+                        scdr << data.index();
+
+                        scdr << data.msg();
+
+}
+
+
+template<>
+eProsima_user_DllExport size_t calculate_serialized_size(
+        eprosima::fastcdr::CdrSizeCalculator& calculator,
+        const PrintRsp& data,
+        size_t& current_alignment)
+{
+    static_cast<void>(data);
+
+    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
+    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
+                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
+                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
+                                current_alignment)};
+
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
+                data.index(), current_alignment);
+
+        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
+                data.msg(), current_alignment);
+
+
+    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);
+
+    return calculated_size;
+}
+
+template<>
+eProsima_user_DllExport void serialize(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintRsp& data)
+{
+    eprosima::fastcdr::Cdr::state current_state(scdr);
+    scdr.begin_serialize_type(current_state,
+            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
+            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
+
+    scdr
+        << eprosima::fastcdr::MemberId(0) << data.index()
+        << eprosima::fastcdr::MemberId(1) << data.msg()
+;
+    scdr.end_serialize_type(current_state);
+}
+
+template<>
+eProsima_user_DllExport void deserialize(
+        eprosima::fastcdr::Cdr& cdr,
+        PrintRsp& data)
+{
+    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
+            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
+            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
+            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
+            {
+                bool ret_value = true;
+                switch (mid.id)
+                {
+                                        case 0:
+                                                dcdr >> data.index();
+                                            break;
+
+                                        case 1:
+                                                dcdr >> data.msg();
+                                            break;
+
+                    default:
+                        ret_value = false;
+                        break;
+                }
+                return ret_value;
+            });
+}
+
+void serialize_key(
+        eprosima::fastcdr::Cdr& scdr,
+        const PrintRsp& data)
+{
+
+    static_cast<void>(scdr);
+    static_cast<void>(data);
+                        scdr << data.index();
+
+                        scdr << data.msg();
+
+}
+
+
 template<>
 eProsima_user_DllExport size_t calculate_serialized_size(
         eprosima::fastcdr::CdrSizeCalculator& calculator,

lib/SystemPubSubTypes.cxx

@@ -31,6 +31,370 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t;
 using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t;
 using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t;
 
+PrintReqPubSubType::PrintReqPubSubType()
+{
+    set_name("PrintReq");
+    uint32_t type_size = PrintReq_max_cdr_typesize;
+    type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
+    max_serialized_type_size = type_size + 4; /*encapsulation*/
+    is_compute_key_provided = false;
+    uint32_t key_length = PrintReq_max_key_cdr_typesize > 16 ? PrintReq_max_key_cdr_typesize : 16;
+    key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
+    memset(key_buffer_, 0, key_length);
+}
+
+PrintReqPubSubType::~PrintReqPubSubType()
+{
+    if (key_buffer_ != nullptr)
+    {
+        free(key_buffer_);
+    }
+}
+
+bool PrintReqPubSubType::serialize(
+        const void* const data,
+        SerializedPayload_t& payload,
+        DataRepresentationId_t data_representation)
+{
+    const PrintReq* p_type = static_cast<const PrintReq*>(data);
+
+    // Object that manages the raw buffer.
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
+    // Object that serializes the data.
+    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
+            data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+            eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
+    payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
+    ser.set_encoding_flag(
+        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+        eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR  :
+        eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
+
+    try
+    {
+        // Serialize encapsulation
+        ser.serialize_encapsulation();
+        // Serialize the object.
+        ser << *p_type;
+        ser.set_dds_cdr_options({0,0});
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return false;
+    }
+
+    // Get the serialized length
+    payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
+    return true;
+}
+
+bool PrintReqPubSubType::deserialize(
+        SerializedPayload_t& payload,
+        void* data)
+{
+    try
+    {
+        // Convert DATA to pointer of your type
+        PrintReq* p_type = static_cast<PrintReq*>(data);
+
+        // Object that manages the raw buffer.
+        eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
+
+        // Object that deserializes the data.
+        eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
+
+        // Deserialize encapsulation.
+        deser.read_encapsulation();
+        payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
+
+        // Deserialize the object.
+        deser >> *p_type;
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t PrintReqPubSubType::calculate_serialized_size(
+        const void* const data,
+        DataRepresentationId_t data_representation)
+{
+    try
+    {
+        eprosima::fastcdr::CdrSizeCalculator calculator(
+            data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+            eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
+        size_t current_alignment {0};
+        return static_cast<uint32_t>(calculator.calculate_serialized_size(
+                    *static_cast<const PrintReq*>(data), current_alignment)) +
+                4u /*encapsulation*/;
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return 0;
+    }
+}
+
+void* PrintReqPubSubType::create_data()
+{
+    return reinterpret_cast<void*>(new PrintReq());
+}
+
+void PrintReqPubSubType::delete_data(
+        void* data)
+{
+    delete(reinterpret_cast<PrintReq*>(data));
+}
+
+bool PrintReqPubSubType::compute_key(
+        SerializedPayload_t& payload,
+        InstanceHandle_t& handle,
+        bool force_md5)
+{
+    if (!is_compute_key_provided)
+    {
+        return false;
+    }
+
+    PrintReq data;
+    if (deserialize(payload, static_cast<void*>(&data)))
+    {
+        return compute_key(static_cast<void*>(&data), handle, force_md5);
+    }
+
+    return false;
+}
+
+bool PrintReqPubSubType::compute_key(
+        const void* const data,
+        InstanceHandle_t& handle,
+        bool force_md5)
+{
+    if (!is_compute_key_provided)
+    {
+        return false;
+    }
+
+    const PrintReq* p_type = static_cast<const PrintReq*>(data);
+
+    // Object that manages the raw buffer.
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
+            PrintReq_max_key_cdr_typesize);
+
+    // Object that serializes the data.
+    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
+    ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
+    eprosima::fastcdr::serialize_key(ser, *p_type);
+    if (force_md5 || PrintReq_max_key_cdr_typesize > 16)
+    {
+        md5_.init();
+        md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
+        md5_.finalize();
+        for (uint8_t i = 0; i < 16; ++i)
+        {
+            handle.value[i] = md5_.digest[i];
+        }
+    }
+    else
+    {
+        for (uint8_t i = 0; i < 16; ++i)
+        {
+            handle.value[i] = key_buffer_[i];
+        }
+    }
+    return true;
+}
+
+void PrintReqPubSubType::register_type_object_representation()
+{
+    register_PrintReq_type_identifier(type_identifiers_);
+}
+
+PrintRspPubSubType::PrintRspPubSubType()
+{
+    set_name("PrintRsp");
+    uint32_t type_size = PrintRsp_max_cdr_typesize;
+    type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
+    max_serialized_type_size = type_size + 4; /*encapsulation*/
+    is_compute_key_provided = false;
+    uint32_t key_length = PrintRsp_max_key_cdr_typesize > 16 ? PrintRsp_max_key_cdr_typesize : 16;
+    key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
+    memset(key_buffer_, 0, key_length);
+}
+
+PrintRspPubSubType::~PrintRspPubSubType()
+{
+    if (key_buffer_ != nullptr)
+    {
+        free(key_buffer_);
+    }
+}
+
+bool PrintRspPubSubType::serialize(
+        const void* const data,
+        SerializedPayload_t& payload,
+        DataRepresentationId_t data_representation)
+{
+    const PrintRsp* p_type = static_cast<const PrintRsp*>(data);
+
+    // Object that manages the raw buffer.
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
+    // Object that serializes the data.
+    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
+            data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+            eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
+    payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
+    ser.set_encoding_flag(
+        data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+        eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR  :
+        eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
+
+    try
+    {
+        // Serialize encapsulation
+        ser.serialize_encapsulation();
+        // Serialize the object.
+        ser << *p_type;
+        ser.set_dds_cdr_options({0,0});
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return false;
+    }
+
+    // Get the serialized length
+    payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
+    return true;
+}
+
+bool PrintRspPubSubType::deserialize(
+        SerializedPayload_t& payload,
+        void* data)
+{
+    try
+    {
+        // Convert DATA to pointer of your type
+        PrintRsp* p_type = static_cast<PrintRsp*>(data);
+
+        // Object that manages the raw buffer.
+        eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
+
+        // Object that deserializes the data.
+        eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
+
+        // Deserialize encapsulation.
+        deser.read_encapsulation();
+        payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
+
+        // Deserialize the object.
+        deser >> *p_type;
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t PrintRspPubSubType::calculate_serialized_size(
+        const void* const data,
+        DataRepresentationId_t data_representation)
+{
+    try
+    {
+        eprosima::fastcdr::CdrSizeCalculator calculator(
+            data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
+            eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
+        size_t current_alignment {0};
+        return static_cast<uint32_t>(calculator.calculate_serialized_size(
+                    *static_cast<const PrintRsp*>(data), current_alignment)) +
+                4u /*encapsulation*/;
+    }
+    catch (eprosima::fastcdr::exception::Exception& /*exception*/)
+    {
+        return 0;
+    }
+}
+
+void* PrintRspPubSubType::create_data()
+{
+    return reinterpret_cast<void*>(new PrintRsp());
+}
+
+void PrintRspPubSubType::delete_data(
+        void* data)
+{
+    delete(reinterpret_cast<PrintRsp*>(data));
+}
+
+bool PrintRspPubSubType::compute_key(
+        SerializedPayload_t& payload,
+        InstanceHandle_t& handle,
+        bool force_md5)
+{
+    if (!is_compute_key_provided)
+    {
+        return false;
+    }
+
+    PrintRsp data;
+    if (deserialize(payload, static_cast<void*>(&data)))
+    {
+        return compute_key(static_cast<void*>(&data), handle, force_md5);
+    }
+
+    return false;
+}
+
+bool PrintRspPubSubType::compute_key(
+        const void* const data,
+        InstanceHandle_t& handle,
+        bool force_md5)
+{
+    if (!is_compute_key_provided)
+    {
+        return false;
+    }
+
+    const PrintRsp* p_type = static_cast<const PrintRsp*>(data);
+
+    // Object that manages the raw buffer.
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
+            PrintRsp_max_key_cdr_typesize);
+
+    // Object that serializes the data.
+    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
+    ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
+    eprosima::fastcdr::serialize_key(ser, *p_type);
+    if (force_md5 || PrintRsp_max_key_cdr_typesize > 16)
+    {
+        md5_.init();
+        md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
+        md5_.finalize();
+        for (uint8_t i = 0; i < 16; ++i)
+        {
+            handle.value[i] = md5_.digest[i];
+        }
+    }
+    else
+    {
+        for (uint8_t i = 0; i < 16; ++i)
+        {
+            handle.value[i] = key_buffer_[i];
+        }
+    }
+    return true;
+}
+
+void PrintRspPubSubType::register_type_object_representation()
+{
+    register_PrintRsp_type_identifier(type_identifiers_);
+}
+
 WeighReqPubSubType::WeighReqPubSubType()
 {
     set_name("WeighReq");

lib/SystemPubSubTypes.hpp

@@ -38,6 +38,168 @@
 #endif  // FASTDDS_GEN_API_VER
 
 
+/*!
+ * @brief This class represents the TopicDataType of the type PrintReq defined by the user in the IDL file.
+ * @ingroup System
+ */
+class PrintReqPubSubType : public eprosima::fastdds::dds::TopicDataType
+{
+public:
+
+    typedef PrintReq type;
+
+    eProsima_user_DllExport PrintReqPubSubType();
+
+    eProsima_user_DllExport ~PrintReqPubSubType() override;
+
+    eProsima_user_DllExport bool serialize(
+            const void* const data,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+    eProsima_user_DllExport bool deserialize(
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            void* data) override;
+
+    eProsima_user_DllExport uint32_t calculate_serialized_size(
+            const void* const data,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+    eProsima_user_DllExport bool compute_key(
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
+
+    eProsima_user_DllExport bool compute_key(
+            const void* const data,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
+
+    eProsima_user_DllExport void* create_data() override;
+
+    eProsima_user_DllExport void delete_data(
+            void* data) override;
+
+    //Register TypeObject representation in Fast DDS TypeObjectRegistry
+    eProsima_user_DllExport void register_type_object_representation() override;
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+    eProsima_user_DllExport inline bool is_bounded() const override
+    {
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+    eProsima_user_DllExport inline bool is_plain(
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+    {
+        static_cast<void>(data_representation);
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+    eProsima_user_DllExport inline bool construct_sample(
+            void* memory) const override
+    {
+        static_cast<void>(memory);
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+private:
+
+    eprosima::fastdds::MD5 md5_;
+    unsigned char* key_buffer_;
+
+};
+
+/*!
+ * @brief This class represents the TopicDataType of the type PrintRsp defined by the user in the IDL file.
+ * @ingroup System
+ */
+class PrintRspPubSubType : public eprosima::fastdds::dds::TopicDataType
+{
+public:
+
+    typedef PrintRsp type;
+
+    eProsima_user_DllExport PrintRspPubSubType();
+
+    eProsima_user_DllExport ~PrintRspPubSubType() override;
+
+    eProsima_user_DllExport bool serialize(
+            const void* const data,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+    eProsima_user_DllExport bool deserialize(
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            void* data) override;
+
+    eProsima_user_DllExport uint32_t calculate_serialized_size(
+            const void* const data,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
+
+    eProsima_user_DllExport bool compute_key(
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
+
+    eProsima_user_DllExport bool compute_key(
+            const void* const data,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
+
+    eProsima_user_DllExport void* create_data() override;
+
+    eProsima_user_DllExport void delete_data(
+            void* data) override;
+
+    //Register TypeObject representation in Fast DDS TypeObjectRegistry
+    eProsima_user_DllExport void register_type_object_representation() override;
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+    eProsima_user_DllExport inline bool is_bounded() const override
+    {
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+    eProsima_user_DllExport inline bool is_plain(
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override
+    {
+        static_cast<void>(data_representation);
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN
+
+#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+    eProsima_user_DllExport inline bool construct_sample(
+            void* memory) const override
+    {
+        static_cast<void>(memory);
+        return false;
+    }
+
+#endif  // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE
+
+private:
+
+    eprosima::fastdds::MD5 md5_;
+    unsigned char* key_buffer_;
+
+};
+
 /*!
  * @brief This class represents the TopicDataType of the type WeighReq defined by the user in the IDL file.
  * @ingroup System

lib/SystemTypeObjectSupport.cxx

@@ -38,6 +38,274 @@
 
 using namespace eprosima::fastdds::dds::xtypes;
 
+// 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(
+        "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 = "PrintReq";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_PrintReq;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_PrintReq;
+        AppliedAnnotationSeq tmp_ann_custom_PrintReq;
+        eprosima::fastcdr::optional<AppliedVerbatimAnnotation> verbatim_PrintReq;
+        if (!tmp_ann_custom_PrintReq.empty())
+        {
+            ann_custom_PrintReq = tmp_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,
+                    "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(
+        "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 = "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,
+                    "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_WeighReq_type_identifier(
         TypeIdentifierPair& type_ids_WeighReq)
@@ -54,13 +322,6 @@ void register_WeighReq_type_identifier(
         QualifiedTypeName type_name_WeighReq = "WeighReq";
         eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_WeighReq;
         eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_WeighReq;
-        AppliedAnnotationSeq tmp_ann_custom_WeighReq;
-        eprosima::fastcdr::optional<AppliedVerbatimAnnotation> verbatim_WeighReq;
-        if (!tmp_ann_custom_WeighReq.empty())
-        {
-            ann_custom_WeighReq = tmp_ann_custom_WeighReq;
-        }
-
         CompleteTypeDetail detail_WeighReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_WeighReq, ann_custom_WeighReq, type_name_WeighReq.to_string());
         CompleteStructHeader header_WeighReq;
         header_WeighReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_WeighReq);

lib/SystemTypeObjectSupport.hpp

@@ -37,6 +37,30 @@
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
+/**
+ * @brief Register PrintReq related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_PrintReq_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+/**
+ * @brief Register PrintRsp related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_PrintRsp_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
 /**
  * @brief Register WeighReq related TypeIdentifier.
  *        Fully-descriptive TypeIdentifiers are directly registered.

lib/base.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#if defined(__GNUC__) && __GNUC__ >= 5
+#pragma GCC diagnostic ignored "-Wunused-result"
+#endif
+
+#include <stdint.h>
+#include <string.h>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <map>
+#include <mutex>
+
+#if defined(__GNUC__) && __GNUC__ < 5
+#define nullptr NULL
+#endif
+
+#ifndef arraysize
+#define arraysize(a)			(sizeof(a)/sizeof(a[0]))
+#endif
+
+#ifndef OT_NAMESPACE_BEGIN
+#	define OT_NAMESPACE_BEGIN		namespace ot {
+#	define OT_NAMESPACE_END			}
+#endif
+
+//数据库操作命令
+#define	Command_AddObject						1		//增加对象 
+#define	Command_DeleteObject					2		//删除对象 
+#define	Command_SyncObject						3		//同步对象 
+#define	Command_VerifyObject					4		//校验对象 
+#define	Command_OrderObject						5		//订购对象 
+#define	Command_CancelOrderObject				6		//取消订购对象 
+#define	Command_GetObject						7		//获取对象 
+#define	Command_SetObject						8		//设置对象 
+#define	Command_GetObjectIDList					9		//获取所有对象编号列表 
+#define	Command_GetObjectList					10		//获取对象列表 
+#define	Command_AddProperty						11		//增加属性 
+#define	Command_DeleteProperty					12		//设置对象 
+#define	Command_EditProperty					13		//修改属性 
+#define	Command_GetPropertyList					14		//获取属性列表 
+
+OT_NAMESPACE_BEGIN
+
+//设备类型
+enum DeviceType
+{
+	DT_Normal = 1,		// 普通设备
+	DT_Network			// 网络设备
+};
+
+typedef std::vector<uint8_t>		ByteArray;
+
+OT_NAMESPACE_END

lib/strcode.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+#include <iostream>
+
+// UTF8、UCS16、GB2312 编码互相转换 
+
+OT_NAMESPACE_BEGIN
+
+std::string WideToGB2312(const wchar_t* s);
+
+std::wstring GB2312ToWide(const char* s);
+
+std::string WideToUTF8(const std::wstring& s);
+
+std::wstring UTF8ToWide(const std::string& s);
+
+std::string UTF8ToGB2312(const char* s);
+
+std::string GB2312ToUTF8(const char* s);
+
+OT_NAMESPACE_END

print/MsgHandler.hpp

@@ -0,0 +1,65 @@
+#ifndef _MSGHANDLER_HPP_
+#define _MSGHANDLER_HPP_
+
+#include <queue>
+#include <mutex>
+#include <vector>
+#include <map>
+
+class MsgHandler {
+public:
+    int fd;
+    std::string device;
+    std::vector<uint8_t> m_PrintData;
+
+    MsgHandler();
+    ~MsgHandler() = default;
+
+    void HandleDdsMsg(const std::map<std::string, std::string>& msg);
+    void EncodeMsg(const std::map<std::string, std::string>& msg);
+    bool SetDevice(const std::string& device);
+
+    virtual bool OpenPort(const std::string& port, const std::string& baudrate);
+    virtual int SendDeviceMsg(const std::vector<uint8_t>& data);
+    virtual int RecvDeviceMsg(std::vector<uint8_t>& data, int timeoutMs);
+    int SendMsg(const std::vector<uint8_t>& data);
+    int RecvMsg(std::vector<uint8_t>& data, int timeoutMs);
+    bool isOpen() const {
+        return fd != -1;
+    }
+    void ClosePort();
+
+private:
+    std::vector<char> BuildLine(int m_max, const std::map<int, std::string>& PointList, int no_line_min = 0, int no_line_max = 0);      //行线条生成器
+    std::vector<char> BuildStringLine(std::map<int, std::string>& PointList);                                                           //行线条生成器
+    std::vector<char> BuildStringLine_HSK33(std::map<int, std::string>& PointList);                                                     //行线条生成器
+
+    void Page_ClearAndSet(std::vector<uint8_t>& Data, char * h1h2h3h4);
+    void Page_ESCL (std::vector<uint8_t>& Data, const char *n1n2, const char *x1x2x3x4, const char *y1y2y3y4,
+    const char *x5x6x7x8, const char *y5y6y7y8, char d, char w);
+    void Page_ESCPC(std::vector<uint8_t>& Data, const char *n1n2, const char *x1x2x3x4, const char *y1y2y3y4,
+    char w, char h, char c, const char * r1r2, const char * s1s2);
+    void Page_ESCRC(std::vector<uint8_t>& Data, const char *n1n2, const char *str);
+    void Page_ESCH(std::vector<uint8_t>& Data, char n, char *x1x2x3x4, char *y1y2y3y4, char *bmp, int bmpsize);
+    void Page_Cut(std::vector<uint8_t>& Data);
+    void Page_End(std::vector<uint8_t>& Data);
+    void GtstrLength(int iVal, char *p);
+
+    void Print1_1(const std::map<std::string, std::string>& msg);
+
+    void Print1_2(const std::map<std::string, std::string>& msg);
+    void Print2_2(const std::map<std::string, std::string>& msg);
+    void Print3_2(const std::map<std::string, std::string>& msg);
+    void Print4_2(const std::map<std::string, std::string>& msg);
+    void Print5_2(const std::map<std::string, std::string>& msg);
+    void Print6_2(const std::map<std::string, std::string>& msg);
+
+    void Print1_3(const std::map<std::string, std::string>& msg);
+    void Print2_3(const std::map<std::string, std::string>& msg);
+    void Print4_3(const std::map<std::string, std::string>& msg);
+    void Print5_3(const std::map<std::string, std::string>& msg);
+    void Print6_3(const std::map<std::string, std::string>& msg);
+    void Print8_3(const std::map<std::string, std::string>& msg);
+};
+
+#endif

print/Publisher.cxx

@@ -0,0 +1,208 @@
+// 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 Publisher.cxx
+ * This file contains the implementation of the publisher functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#include "Publisher.hpp"
+
+#include <condition_variable>
+#include <csignal>
+#include <stdexcept>
+#include <thread>
+
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/log/Log.hpp>
+#include <fastdds/dds/publisher/DataWriter.hpp>
+#include <fastdds/dds/publisher/Publisher.hpp>
+#include <fastdds/dds/publisher/qos/DataWriterQos.hpp>
+#include <fastdds/dds/publisher/qos/PublisherQos.hpp>
+
+#include "SystemPubSubTypes.hpp"
+
+#include "msg.hpp"
+#include "MsgHandler.hpp"
+
+using namespace eprosima::fastdds::dds;
+
+PublisherApp::PublisherApp(
+        const int& domain_id)
+    : factory_(nullptr)
+    , participant_(nullptr)
+    , publisher_(nullptr)
+    , topic_(nullptr)
+    , writer_(nullptr)
+    , type_(new PrintRspPubSubType())
+    , matched_(0)
+    , samples_sent_(0)
+    , stop_(false)
+{
+    //
+
+    // Create the participant
+    DomainParticipantQos pqos = PARTICIPANT_QOS_DEFAULT;
+    pqos.name("Print_pub_participant");
+    pqos.wire_protocol().builtin.discovery_config.leaseDuration = Duration_t(60, 0);
+    pqos.wire_protocol().builtin.discovery_config.leaseDuration_announcementperiod = Duration_t(30, 0);
+    factory_ = DomainParticipantFactory::get_shared_instance();
+    participant_ = factory_->create_participant(domain_id, pqos, nullptr, StatusMask::none());
+    if (participant_ == nullptr)
+    {
+        throw std::runtime_error("PrintRsp Participant initialization failed");
+    }
+
+    // Register the type
+    type_.register_type(participant_);
+
+    // Create the publisher
+    PublisherQos pub_qos = PUBLISHER_QOS_DEFAULT;
+    participant_->get_default_publisher_qos(pub_qos);
+    publisher_ = participant_->create_publisher(pub_qos, nullptr, StatusMask::none());
+    if (publisher_ == nullptr)
+    {
+        throw std::runtime_error("PrintRsp Publisher initialization failed");
+    }
+
+    // Create the topic
+    TopicQos topic_qos = TOPIC_QOS_DEFAULT;
+    participant_->get_default_topic_qos(topic_qos);
+    topic_ = participant_->create_topic("PrintRspTopic", type_.get_type_name(), topic_qos);
+    if (topic_ == nullptr)
+    {
+        throw std::runtime_error("PrintRsp Topic initialization failed");
+    }
+
+    // Create the data writer
+    DataWriterQos writer_qos = DATAWRITER_QOS_DEFAULT;
+    publisher_->get_default_datawriter_qos(writer_qos);
+    writer_qos.reliability().kind = ReliabilityQosPolicyKind::RELIABLE_RELIABILITY_QOS;
+    writer_qos.durability().kind = DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS;
+    writer_qos.history().kind = HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS;
+    writer_ = publisher_->create_datawriter(topic_, writer_qos, this, StatusMask::all());
+    if (writer_ == nullptr)
+    {
+        throw std::runtime_error("PrintRsp DataWriter initialization failed");
+    }
+}
+
+PublisherApp::~PublisherApp()
+{
+    if (nullptr != participant_)
+    {
+        // Delete DDS entities contained within the DomainParticipant
+        participant_->delete_contained_entities();
+
+        // Delete DomainParticipant
+        factory_->delete_participant(participant_);
+    }
+}
+
+void PublisherApp::on_publication_matched(
+        DataWriter* writer,
+        const PublicationMatchedStatus& info)
+{
+    if (info.current_count_change == 1)
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            matched_ = info.current_count;
+        }
+        std::cout << writer->get_topic()->get_name() << " Publisher matched." << std::endl;
+        cv_.notify_one();
+    }
+    else if (info.current_count_change == -1)
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            matched_ = info.current_count;
+        }
+        std::cout << writer->get_topic()->get_name() << " Publisher unmatched." << std::endl;
+    }
+    else
+    {
+        std::cout << info.current_count_change
+                  << " is not a valid value for PublicationMatchedStatus current count change" << std::endl;
+    }
+}
+
+void PublisherApp::run(std::shared_ptr<MsgHandler> handler)
+{
+    while (!is_stopped())
+    {
+        std::unique_lock<std::mutex> lock(MsgData::queue_cv_mtx_, std::try_to_lock);
+        if (lock.owns_lock())
+        {
+            if(!MsgData::PrintReq_queue_.empty())
+            {
+                PrintReq req = std::move(MsgData::PrintReq_queue_.front());
+                MsgData::PrintReq_queue_.pop();
+                lock.unlock();
+
+                std::cout << "index: " << req.index() << std::endl;
+                handler->HandleDdsMsg(req.msg());
+
+                PrintRsp rsp;
+                rsp.index() = req.index();
+                rsp.msg() = "success";
+                writer_->write(&rsp);
+            }
+            else
+            {
+                lock.unlock();
+            }
+        }
+        // Wait for period or stop event
+        std::unique_lock<std::mutex> period_lock(mutex_);
+        cv_.wait_for(period_lock, std::chrono::milliseconds(period_ms_), [this]()
+                {
+                    return is_stopped();
+                });
+    }
+}
+
+
+bool PublisherApp::publish()
+{
+    bool ret = false;
+    // Wait for the data endpoints discovery
+    std::unique_lock<std::mutex> matched_lock(mutex_);
+    cv_.wait(matched_lock, [&]()
+            {
+                // at least one has been discovered
+                return ((matched_ > 0) || is_stopped());
+            });
+
+    if (!is_stopped())
+    {
+        /* Initialize your structure here */
+        WeighRsp sample_;
+        ret = (RETCODE_OK == writer_->write(&sample_));
+    }
+    return ret;
+}
+
+bool PublisherApp::is_stopped()
+{
+    return stop_.load();
+}
+
+void PublisherApp::stop()
+{
+    stop_.store(true);
+    cv_.notify_one();
+}

print/Publisher.hpp

@@ -0,0 +1,76 @@
+// 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 PublisherApp.hpp
+ * This header file contains the declaration of the publisher functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#ifndef FAST_DDS_GENERATED__PUBLISHERAPP_HPP
+#define FAST_DDS_GENERATED__PUBLISHERAPP_HPP
+
+#include <condition_variable>
+
+#include <fastdds/dds/domain/DomainParticipant.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/publisher/DataWriterListener.hpp>
+#include <fastdds/dds/topic/TypeSupport.hpp>
+
+#include "MsgHandler.hpp"
+
+class PublisherApp : public eprosima::fastdds::dds::DataWriterListener
+{
+public:
+
+    PublisherApp(
+            const int& domain_id);
+
+    ~PublisherApp();
+
+    //! Publisher matched method
+    void on_publication_matched(
+            eprosima::fastdds::dds::DataWriter* writer,
+            const eprosima::fastdds::dds::PublicationMatchedStatus& info) override;
+
+    //! Run publisher
+    void run(std::shared_ptr<MsgHandler> handler);
+
+    //! Trigger the end of execution
+    void stop();
+
+private:
+
+    //! Return the current state of execution
+    bool is_stopped();
+
+    //! Publish a sample
+    bool publish();
+
+    std::shared_ptr<eprosima::fastdds::dds::DomainParticipantFactory> factory_;
+    eprosima::fastdds::dds::DomainParticipant* participant_;
+    eprosima::fastdds::dds::Publisher* publisher_;
+    eprosima::fastdds::dds::Topic* topic_;
+    eprosima::fastdds::dds::DataWriter* writer_;
+    eprosima::fastdds::dds::TypeSupport type_;
+    std::condition_variable cv_;
+    int32_t matched_;
+    std::mutex mutex_;
+    const uint32_t period_ms_ = 100; // in ms
+    uint16_t samples_sent_;
+    std::atomic<bool> stop_;
+};
+
+#endif // FAST_DDS_GENERATED__PUBLISHERAPP_HPP

print/Subscriber.cxx

@@ -0,0 +1,171 @@
+// 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 Subscriber.cxx
+ * This file contains the implementation of the subscriber functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#include "Subscriber.hpp"
+
+#include <condition_variable>
+#include <stdexcept>
+
+#include <fastdds/dds/core/status/SubscriptionMatchedStatus.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/subscriber/DataReader.hpp>
+#include <fastdds/dds/subscriber/qos/DataReaderQos.hpp>
+#include <fastdds/dds/subscriber/qos/SubscriberQos.hpp>
+#include <fastdds/dds/subscriber/SampleInfo.hpp>
+#include <fastdds/dds/subscriber/Subscriber.hpp>
+
+#include "SystemPubSubTypes.hpp"
+
+#include "msg.hpp"
+
+using namespace eprosima::fastdds::dds;
+
+SubscriberApp::SubscriberApp(
+        const int& domain_id)
+    : factory_(nullptr)
+    , participant_(nullptr)
+    , subscriber_(nullptr)
+    , topic_(nullptr)
+    , reader_(nullptr)
+    , type_(new PrintReqPubSubType())
+    , samples_received_(0)
+    , stop_(false)
+{
+    // Create the participant
+    DomainParticipantQos pqos = PARTICIPANT_QOS_DEFAULT;
+    pqos.name("Print_sub_participant");
+    pqos.wire_protocol().builtin.discovery_config.leaseDuration = Duration_t(60, 0);
+    pqos.wire_protocol().builtin.discovery_config.leaseDuration_announcementperiod = Duration_t(30, 0);
+    factory_ = DomainParticipantFactory::get_shared_instance();
+    participant_ = factory_->create_participant(domain_id, pqos, nullptr, StatusMask::none());
+    if (participant_ == nullptr)
+    {
+        throw std::runtime_error("PrintReq Participant initialization failed");
+    }
+
+    // Register the type
+    type_.register_type(participant_);
+
+    // Create the subscriber
+    SubscriberQos sub_qos = SUBSCRIBER_QOS_DEFAULT;
+    participant_->get_default_subscriber_qos(sub_qos);
+    subscriber_ = participant_->create_subscriber(sub_qos, nullptr, StatusMask::none());
+    if (subscriber_ == nullptr)
+    {
+        throw std::runtime_error("PrintReq Subscriber initialization failed");
+    }
+
+    // Create the topic
+    TopicQos topic_qos = TOPIC_QOS_DEFAULT;
+    participant_->get_default_topic_qos(topic_qos);
+    topic_ = participant_->create_topic("PrintReqTopic", type_.get_type_name(), topic_qos);
+    if (topic_ == nullptr)
+    {
+        throw std::runtime_error("PrintReq Topic initialization failed");
+    }
+
+    // Create the reader
+    DataReaderQos reader_qos = DATAREADER_QOS_DEFAULT;
+    subscriber_->get_default_datareader_qos(reader_qos);
+    reader_qos.reliability().kind = ReliabilityQosPolicyKind::RELIABLE_RELIABILITY_QOS;
+    reader_qos.durability().kind = DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS;
+    reader_qos.history().kind = HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS;
+    reader_ = subscriber_->create_datareader(topic_, reader_qos, this, StatusMask::all());
+    if (reader_ == nullptr)
+    {
+        throw std::runtime_error("PrintReq DataReader initialization failed");
+    }
+}
+
+SubscriberApp::~SubscriberApp()
+{
+    if (nullptr != participant_)
+    {
+        // Delete DDS entities contained within the DomainParticipant
+        participant_->delete_contained_entities();
+
+        // Delete DomainParticipant
+        factory_->delete_participant(participant_);
+    }
+}
+
+void SubscriberApp::on_subscription_matched(
+        DataReader* reader,
+        const SubscriptionMatchedStatus& info)
+{
+    if (info.current_count_change == 1)
+    {
+        std::cout << reader->get_topicdescription()->get_name() << " Subscriber matched." << std::endl;
+    }
+    else if (info.current_count_change == -1)
+    {
+        std::cout << reader->get_topicdescription()->get_name() << " Subscriber unmatched." << std::endl;
+    }
+    else
+    {
+        std::cout << info.current_count_change
+                  << " is not a valid value for SubscriptionMatchedStatus current count change" << std::endl;
+    }
+}
+
+void SubscriberApp::on_data_available(
+        DataReader* reader)
+{
+    SampleInfo info;
+    std::string topic_name = reader->get_topicdescription()->get_name();
+    std::cout << topic_name << std::endl;
+
+    if (topic_name == "PrintReqTopic")
+    {
+        PrintReq sample_;
+        while ((!is_stopped()) && (RETCODE_OK == reader->take_next_sample(&sample_, &info)))
+        {
+            if ((info.instance_state == ALIVE_INSTANCE_STATE) && info.valid_data)
+            {
+                {
+                    std::unique_lock<std::mutex> lock(MsgData::queue_cv_mtx_);
+                    MsgData::PrintReq_queue_.push(std::move(sample_));
+                    lock.unlock();
+                }
+            }
+        }
+    }
+}
+
+void SubscriberApp::run()
+{
+    std::unique_lock<std::mutex> lck(terminate_cv_mtx_);
+    terminate_cv_.wait(lck, [this]
+            {
+                return is_stopped();
+            });
+}
+
+bool SubscriberApp::is_stopped()
+{
+    return stop_.load();
+}
+
+void SubscriberApp::stop()
+{
+    stop_.store(true);
+    terminate_cv_.notify_all();
+}

print/Subscriber.hpp

@@ -0,0 +1,75 @@
+// 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 SubscriberApp.hpp
+ * This header file contains the declaration of the subscriber functions.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#ifndef FAST_DDS_GENERATED__SUBSCRIBERAPP_HPP
+#define FAST_DDS_GENERATED__SUBSCRIBERAPP_HPP
+
+#include <condition_variable>
+
+#include <fastdds/dds/domain/DomainParticipant.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include <fastdds/dds/topic/TypeSupport.hpp>
+
+#include "System.hpp"
+
+class SubscriberApp : public eprosima::fastdds::dds::DataReaderListener
+{
+public:
+
+    SubscriberApp(
+            const int& domain_id);
+
+    virtual ~SubscriberApp();
+
+    //! Subscription callback
+    void on_data_available(
+            eprosima::fastdds::dds::DataReader* reader) override;
+
+    //! Subscriber matched method
+    void on_subscription_matched(
+            eprosima::fastdds::dds::DataReader* reader,
+            const eprosima::fastdds::dds::SubscriptionMatchedStatus& info) override;
+
+    //! Run subscriber
+    void run();
+
+    //! Trigger the end of execution
+    void stop();
+
+private:
+
+    //! Return the current state of execution
+    bool is_stopped();
+
+    std::shared_ptr<eprosima::fastdds::dds::DomainParticipantFactory> factory_;
+    eprosima::fastdds::dds::DomainParticipant* participant_;
+    eprosima::fastdds::dds::Subscriber* subscriber_;
+    eprosima::fastdds::dds::Topic* topic_;
+    eprosima::fastdds::dds::DataReader* reader_;
+    eprosima::fastdds::dds::TypeSupport type_;
+    uint16_t samples_received_;
+    std::atomic<bool> stop_;
+    mutable std::mutex terminate_cv_mtx_;
+    std::condition_variable terminate_cv_;
+};
+
+#endif // FAST_DDS_GENERATED__SUBSCRIBERAPP_HPP

print/main.cxx

@@ -0,0 +1,168 @@
+// 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 Systemmain.cxx
+ * This file acts as a main entry point to the application.
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#include <csignal>
+#include <cstring>
+#include <functional>
+#include <iostream>
+#include <stdexcept>
+#include <thread>
+
+#include <fastdds/dds/log/Log.hpp>
+
+#include "Subscriber.hpp"
+#include "Publisher.hpp"
+#include "SerialMsgHandler.hpp"
+#include "msg.hpp"
+
+#define VERSION "v1.0"
+
+using eprosima::fastdds::dds::Log;
+
+std::function<void(int)> stop_handler;
+void signal_handler(
+        int signum)
+{
+    stop_handler(signum);
+}
+
+std::string parse_signal(
+        const int& signum)
+{
+    switch (signum)
+    {
+        case SIGINT:
+            return "SIGINT";
+        case SIGTERM:
+            return "SIGTERM";
+#ifndef _WIN32
+        case SIGQUIT:
+            return "SIGQUIT";
+        case SIGHUP:
+            return "SIGHUP";
+#endif // _WIN32
+        default:
+            return "UNKNOWN SIGNAL";
+    }
+}
+
+std::queue<PrintReq> MsgData::PrintReq_queue_;
+std::mutex MsgData::queue_cv_mtx_;
+
+int main(int argc, char** argv)
+{
+    auto ret = EXIT_SUCCESS;
+    std::shared_ptr<SubscriberApp> sub;
+    std::shared_ptr<PublisherApp> pub;
+    std::shared_ptr<MsgHandler> dev;
+
+    int domain_id = 0;
+    const char* interface = "serial";
+    const char* port = "ttyS1";
+    const char* baudrate = "9600";
+    const char* device = "Toledo";
+
+    for (int i = 1; i < argc; i++)
+    {
+        if (strcmp(argv[i], "--domain") == 0 && i + 1 < argc)
+        {
+            domain_id = atoi(argv[++i]);
+        }
+        else if (strcmp(argv[i], "--interface") == 0 && i + 1 < argc)
+        {
+            interface = argv[++i];
+        }
+        else if (strcmp(argv[i], "--port") == 0 && i + 1 < argc)
+        {
+            port = argv[++i];
+        }
+        else if (strcmp(argv[i], "--baudrate") == 0 && i + 1 < argc)
+        {
+            baudrate = argv[++i];
+        }
+        else if (strcmp(argv[i], "--device") == 0 && i + 1 < argc)
+        {
+            device = argv[++i];
+        }
+        else if (strcmp(argv[i], "--version") == 0)
+        {
+            std::cout << "Vesrion: " << VERSION << "\n";
+            return EXIT_SUCCESS;
+        }
+        else if (strcmp(argv[i], "--help") == 0)
+        {
+            std::cout << "Usage: [options]\n"
+                      << "Options:\n"
+                      << "  --domain        Set domain ID\n"
+                      << "  --interface     Set interface (e.g., serial)\n"
+                      << "  --baudrate      Set baudrate (e.g., 9600)\n"
+                      << "  --port          Set port name (e.g., ttyS1)\n"
+                      << "  --device        Set device name (e.g., NP80A)\n"
+                      << "  --version       Show software Version\n"
+                      << "  --help          Show this help message\n";
+            return EXIT_SUCCESS;
+        }
+        else
+        {
+            std::cerr << "Unknown option: " << argv[i] << "\n";
+            std::cout << "Usage: [options]\n"
+                      << "Options:\n"
+                      << "  --domain        Set domain ID\n"
+                      << "  --interface     Set interface (e.g., serial)\n"
+                      << "  --baudrate      Set baudrate (e.g., 9600)\n"
+                      << "  --port          Set port name (e.g., ttyS1)\n"
+                      << "  --device        Set device name (e.g., NP80A)\n"
+                      << "  --version       Show software Version\n"
+                      << "  --help          Show this help message\n";
+            return EXIT_FAILURE;
+        }
+    }
+
+    sub = std::make_shared<SubscriberApp>(domain_id);
+    pub = std::make_shared<PublisherApp>(domain_id);
+    dev = std::make_shared<SerialMsgHandler>();
+
+    dev->OpenPort(port, baudrate);
+    dev->SetDevice(device);
+
+    std::thread pub_thread(&PublisherApp::run, pub, dev);
+
+    std::cout << "Program is running. Please press Ctrl+C to stop at any time." << std::endl;
+
+    stop_handler = [&](int signum)
+            {
+                std::cout << "\n" << parse_signal(signum) << " received, stopping " << argv[1]
+                          << " execution." << std::endl;
+                pub->stop();
+            };
+
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+#ifndef _WIN32
+    signal(SIGQUIT, signal_handler);
+    signal(SIGHUP, signal_handler);
+#endif // _WIN32
+
+    pub_thread.join();
+
+    Log::Reset();
+    return ret;
+}

print/msg.hpp

@@ -0,0 +1,14 @@
+#ifndef _MSG_HPP_
+#define _MSG_HPP_
+
+#include <queue>
+#include <mutex>
+#include "System.hpp"
+
+class MsgData {
+public:
+    static std::queue<PrintReq> PrintReq_queue_;
+    static std::mutex queue_cv_mtx_;
+};
+
+#endif