Add kGraphGRC message

Part of task #246
Signed-off-by: Sergio Martins <[email protected]>

Author: iamsergio

core/include/gnuradio-4.0/Graph.hpp

@@ -34,6 +34,10 @@
 
 namespace gr {
 
+class Graph;
+std::string  saveGrc(PluginLoader& loader, const gr::Graph& rootGraph);
+inline Graph loadGrc(PluginLoader& loader, std::string_view yamlSrc, std::source_location location = std::source_location::current());
+
 namespace graph::property {
 inline static const char* kEmplaceBlock = "EmplaceBlock";
 inline static const char* kRemoveBlock  = "RemoveBlock";
@@ -54,6 +58,8 @@ inline static const char* kEdgeRemoved  = "EdgeRemoved";
 inline static const char* kGraphInspect   = "GraphInspect";
 inline static const char* kGraphInspected = "GraphInspected";
 
+inline static const char* kGraphGRC = "GraphGRC";
+
 inline static const char* kRegistryBlockTypes = "RegistryBlockTypes";
 
 inline static const char* kSubgraphExportPort   = "SubgraphExportPort";
@@ -344,6 +350,7 @@ class Graph : public gr::Block<Graph> {
         propertyCallbacks[graph::property::kEmplaceEdge]        = std::mem_fn(&Graph::propertyCallbackEmplaceEdge);
         propertyCallbacks[graph::property::kRemoveEdge]         = std::mem_fn(&Graph::propertyCallbackRemoveEdge);
         propertyCallbacks[graph::property::kGraphInspect]       = std::mem_fn(&Graph::propertyCallbackGraphInspect);
+        propertyCallbacks[graph::property::kGraphGRC]           = std::mem_fn(&Graph::propertyCallbackGraphGRC);
         propertyCallbacks[graph::property::kRegistryBlockTypes] = std::mem_fn(&Graph::propertyCallbackRegistryBlockTypes);
     }
 
@@ -702,6 +709,25 @@ class Graph : public gr::Block<Graph> {
         return message;
     }
 
+    std::optional<Message> propertyCallbackGraphGRC([[maybe_unused]] std::string_view propertyName, Message message) {
+        assert(propertyName == graph::property::kGraphGRC);
+
+        if (message.cmd == message::Command::Get) {
+            message.data = property_map{{"value", gr::saveGrc(*_pluginLoader, *this)}};
+        } else if (message.cmd == message::Command::Set) {
+            const auto& data        = message.data.value();
+            auto        yamlContent = std::get<std::string>(data.at("value"s));
+            *this                   = gr::loadGrc(*_pluginLoader, yamlContent);
+
+            setTopologyChanged();
+
+        } else {
+            throw gr::exception(fmt::format("Unexpected command type {}", message.cmd));
+        }
+
+        return message;
+    }
+
     std::optional<Message> propertyCallbackRegistryBlockTypes([[maybe_unused]] std::string_view propertyName, Message message) {
         assert(propertyName == graph::property::kRegistryBlockTypes);
         message.data = property_map{{"types", _pluginLoader->knownBlocks()}};
@@ -1467,7 +1493,7 @@ inline gr::property_map saveGraphToMap(PluginLoader& loader, const gr::Graph& ro
 
 } // namespace detail
 
-inline gr::Graph loadGrc(PluginLoader& loader, std::string_view yamlSrc, std::source_location location = std::source_location::current()) {
+inline gr::Graph loadGrc(PluginLoader& loader, std::string_view yamlSrc, std::source_location location) {
     Graph      resultGraph;
     const auto yaml = pmtv::yaml::deserialize(yamlSrc);
     if (!yaml) {

core/test/qa_GraphMessages.cpp

@@ -10,6 +10,8 @@
 
 #include "message_utils.hpp"
 
+#include <filesystem>
+
 using namespace std::chrono_literals;
 using namespace std::string_literals;
 
@@ -305,6 +307,47 @@ const boost::ut::suite NonRunningGraphTests = [] {
             }
         };
     };
+
+    "GRC tests"_test = [] {
+        gr::MsgPortOut toGraph;
+        gr::Graph      testGraph(context->loader);
+        gr::MsgPortIn  fromGraph;
+
+        expect(eq(ConnectionResult::SUCCESS, toGraph.connect(testGraph.msgIn)));
+        expect(eq(ConnectionResult::SUCCESS, testGraph.msgOut.connect(fromGraph)));
+
+        testGraph.emplaceBlock("gr::testing::Copy<float32>", {});
+        testGraph.emplaceBlock("gr::testing::Copy<float32>", {});
+
+        expect(eq(getNReplyMessages(fromGraph), 2UZ)); // consume 2 messages from emplace
+        consumeAllReplyMessages(fromGraph);
+        expect(eq(getNReplyMessages(fromGraph), 0UZ));
+
+        sendMessage<Get>(toGraph, testGraph.unique_name, graph::property::kGraphGRC, {});
+        expect(nothrow([&] { testGraph.processScheduledMessages(); })) << "manually execute processing of messages";
+
+        expect(eq(getNReplyMessages(fromGraph), 1UZ));
+        const Message reply = getAndConsumeFirstReplyMessage(fromGraph);
+
+        expect(reply.data.has_value()) << "Reply should contain data";
+        if (reply.data.has_value()) {
+            const auto& data = reply.data.value();
+            expect(data.contains("value")) << "Reply should contain 'value' field";
+            const auto& yaml = std::get<std::string>(data.at("value"));
+            expect(!yaml.empty()) << "YAML string should not be empty";
+            fmt::println("YAML content:\n{}", yaml);
+
+            // verify well formed by loading from yaml
+            auto graphFromYaml = gr::loadGrc(context->loader, yaml);
+            expect(eq(graphFromYaml.blocks().size(), 2UZ)) << fmt::format("Expected 2 blocks in loaded graph, got {} blocks", graphFromYaml.blocks().size());
+
+            "Set GRC YAML"_test = [&] {
+                sendMessage<Set>(toGraph, testGraph.unique_name, graph::property::kGraphGRC, {{"value", yaml}});
+                expect(nothrow([&] { testGraph.processScheduledMessages(); })) << "manually execute processing of messages";
+                expect(eq(testGraph.blocks().size(), 2UZ)) << "Expected 2 blocks after reloading GRC";
+            };
+        }
+    };
 };
 
 const boost::ut::suite RunningGraphTests = [] {