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/master/demo_nodes_cpp/src/topics/listener_serialized_message.cpp#L56-L63)

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 used in QML

   //Ros2Subscription.qml
    import QtQuick 2.0    
    QtObject {
        id: main

        required property string topic_name
        required property string topic_type
        property bool echo: false
        property var current_value: null //the last message received on this subscription

        function callback(msg) {
            if(echo){
                console.log('received message on topic', topic_name, JSON.stringify(msg))
            }
            current_value = msg
        }

        readonly property var init : function() {
            create_subscriber(topic_type, topic_name, callback)
        }
    }

And to display this value

//Ros2MsgFeildDisplay.qml
import QtQuick.Controls 2.15
import QtQuick.Layouts
import QtQml 2.15

//Display a feild of a topic

GroupBox {
    id: main
    required property string name
    required property string topic_name
    required property string topic_type
    required property var default_value
    property bool echo: false
    property alias current_value: subscription.current_value
    property alias init: subscription.init
    property var feilds : []

    property var get_feild_from_msg : function(msg) { //this can be replaced with other logic if needed
        for (const elem of feilds) {
            msg = msg[elem]
        }
        return msg
    }

    Subscription {
        id: subscription
        topic_name: main.topic_name
        topic_type: main.topic_type
        echo: main.echo
    }

    RowLayout {
        id: layout
        property alias label_text: value_label.text
        Label { text: name }
        Label {
            id: value_label
            text: current_value ? get_feild_from_msg(current_value) : default_value
        }
    }
}