Deserialise a `SerializedMessage` into something other than a ROS2 message. E.g JSON

edit

You can use rclcpp::Serialization<MessageT>::deserialize_message to deserialise a SerializedMessage into MessageT where MessageT is any ROS2 message. E.g.

std::shared_ptr<rclcpp::SerializedMessage> msg;
using MessageT = std_msgs::msg::String;
        MessageT string_msg;
        auto serializer = rclcpp::Serialization<MessageT>();
        serializer.deserialize_message(msg.get(), &string_msg);
        // Finally print the ROS2 message data
        std::cout << "serialized data after deserialization: " << string_msg.data << std::endl;

(Example from https://github.com/ros2/demos/blob/ma...)

But what if I wanted to deserialise into something other than a ROS2 message?

E.g

#include <nlohmann/json.hpp>
using nlohmann::json;

rclcpp::Serialization<json>().deserialize_message()

Or

rclcpp::Serialization<QVariantMap>().deserialize_message()

What would be the best way to go about doing this? Could I create a template specialisation? And what would be the easiest way to inspect the SerializedMessage and generate my own class from this?

Are there any functions from the implementation of rclcpp::Serialization<MessageT>::deserialize_message (where MessageT is a ROS2 message) that I could use in my template specialisation for when MessageT is not a ROS2 message?

Edit - Extra info in response to gvdhooms comment :

The reason why I want to do this is I am trying to create a topic echo node in C++. After I have done this, I then want to expose the rclcpp::create_generic_subscription to QML, so I can create subscriptions to topics in the QML language.

Using the resource you provided, here is my code for the cpp topic echo node:

#include <iostream>
#include "rclcpp/node.hpp"
#include "rclcpp/serialization.hpp"
#include "std_msgs/msg/string.hpp"
#include "dynmsg_demo/typesupport_utils.hpp"
#include "dynmsg_demo/message_reading.hpp"
#include <memory.h>


int main(int argc, char* argv[])
{
  std::vector<std::string> arguments(argv + 1, argv + argc);

  auto topic_name = arguments.at(0);
  auto topic_type = arguments.at(1);

  rclcpp::init(argc, argv);
  auto node = rclcpp::Node("topic_echo_cpp");

  auto callback = [&topic_type](std::shared_ptr<rclcpp::SerializedMessage> msg){

    InterfaceTypeName topic_type_name = get_topic_type_from_string_type(topic_type);
    const rosidl_message_type_support_t* ts = get_type_support(topic_type_name);
    auto deserializer = rclcpp::SerializationBase(ts);
    auto result = RosMessage();
    deserializer.deserialize_message(msg.get(), &result);
    auto yaml_result = message_to_yaml(result);
    std::cout << yaml_result << std::endl;

  };

  node.create_generic_subscription(topic_name, topic_type, 10, callback);

  return 0;
}

Here is my prototype for exposing rclcpp::create_generic_subscription to QML. It is currently in python, because type introspection is built into the language in python, but I would like to do this in C++.

@Slot(str, str, QJSValue)
def create_subscriber(self, topic_type: str, topic_name: str, js_callback: QJSValue):
    #Called from MainThread (QML)

    MsgType = get_message(topic_type)
    self.node.create_subscription(MsgType, topic_name, self.make_subscription_callback(js_callback), 10)
    self.node.get_logger().info(f"created subscriber to topic {topic_name}")

def make_subscription_callback(self, js_callback: QJSValue):
    #Called from MainThread (QML)
    def subscription_callback(msg: Ros2MessageProtocol):
        #Called from ThreadPoolExecutorTheaed (ROS2)
        self.node.get_logger().debug(f'executing js callback with {msg}')
        od = message_to_ordereddict(msg)
        data: str = json.dumps(od)
        #Emit signal so this can be done in the QML thread
        self.execute_subscription_js_callback_sig.emit(js_callback, data)
    return subscription_callback

@Slot(QJSValue, str)
def execute_subscription_js_callback(self, js_callback: QJSValue, data: str):
    #Called from MainThread (QML)
    converter = self.engine.evaluate("JSON.parse")
    qjsvalue = converter.call([QJSValue(data)])
    js_callback.call([qjsvalue])

And how this is ... (more)