feat: allow using user defiend ids with insert_node_with_id

Author: JuanCarlosgg

api/dsr_api.cpp

@@ -225,6 +225,48 @@ template std::optional<uint64_t>  DSRGraph::insert_node<DSR::Node &&>(DSR::Node&
 template std::optional<uint64_t>  DSRGraph::insert_node<DSR::Node&>(DSR::Node&);
 
 
+template<typename No>
+std::optional<uint64_t> DSRGraph::insert_node_with_id(No &&node)
+    requires (std::is_same_v<std::remove_reference_t<No>, DSR::Node>)
+{
+    std::optional<IDL::MvregNode> delta;
+    bool inserted = false;
+    {
+        std::unique_lock<std::shared_mutex> lock(_mutex);
+        std::shared_lock<std::shared_mutex> lck_cache(_mutex_cache_maps);
+        //Check id
+        if (nodes.contains(node.id())) {
+            DSR_LOG_WARNING("[INSERT_NODE_WITH_ID] Node id already exists", node.id(), node.type());
+            return {};
+        }
+        if (node.name().empty() or name_map.contains(node.name()))
+            node.name(node.type() + "_" + id_generator::hex_string(node.id()));
+        lck_cache.unlock();
+        std::tie(inserted, delta) = insert_node_(user_node_to_crdt(std::forward<No>(node)));
+    }
+    if (inserted)
+    {
+        if (!copy)
+        {
+            if (delta.has_value())
+            {
+                dsrpub_node.write(&delta.value());
+                DSR_LOG_DEBUG("[INSERT_NODE_WITH_ID] emitting update_node_signal", node.id(), node.type());
+                emitter.update_node_signal(node.id(), node.type(), SignalInfo{agent_id});
+                for (const auto &[k, v]: node.fano())
+                {
+                    emitter.update_edge_signal(node.id(), k.first, k.second,  SignalInfo{agent_id});
+                }
+            }
+        }
+        return node.id();
+    }
+    return {};
+}
+
+template std::optional<uint64_t>  DSRGraph::insert_node_with_id<DSR::Node &&>(DSR::Node&&);
+template std::optional<uint64_t>  DSRGraph::insert_node_with_id<DSR::Node&>(DSR::Node&);
+
 std::tuple<bool, std::optional<std::vector<IDL::MvregNodeAttr>>> DSRGraph::update_node_(CRDTNode &&node)
 {
 

api/include/dsr/api/dsr_api.h

@@ -91,6 +91,8 @@ namespace DSR
         template<typename No>
         std::optional<uint64_t> insert_node(No &&node) requires (std::is_same_v<std::remove_reference_t<No>, DSR::Node>);
         template<typename No>
+        std::optional<uint64_t> insert_node_with_id(No &&node) requires (std::is_same_v<std::remove_reference_t<No>, DSR::Node>);
+        template<typename No>
         bool update_node(No &&node) requires (std::is_same_v<std::remove_cvref_t<No>, DSR::Node>);
         bool delete_node(const DSR::Node& node);
         bool delete_node(const std::string &name);

tests/graph/node_operations.cpp

@@ -133,7 +133,70 @@ TEST_CASE("Graph node operations", "[NODE]") {
 }
 
 
-TEST_CASE("Node creation", 
+TEST_CASE("Insert node with specific id", "[NODE]") {
+
+    auto filename = make_empty_config_file();
+    DSRGraph G(random_string(10), rand() % 1200, filename);
+
+    SECTION("Insert a node with a specific id") {
+        auto node_name = random_string();
+        uint64_t specific_id = 5000;
+        auto n = Node::create<testtype_node_type>(node_name);
+        n.id(specific_id);
+        std::optional<uint64_t> r = G.insert_node_with_id(n);
+        REQUIRE(r.has_value());
+        REQUIRE(r.value() == specific_id);
+        std::optional<Node> retrieved = G.get_node(specific_id);
+        REQUIRE(retrieved.has_value());
+        REQUIRE(retrieved->name() == node_name);
+    }
+
+    SECTION("Insert a node with a duplicate id fails") {
+        auto n1 = Node::create<testtype_node_type>(random_string());
+        uint64_t specific_id = 6000;
+        n1.id(specific_id);
+        std::optional<uint64_t> r1 = G.insert_node_with_id(n1);
+        REQUIRE(r1.has_value());
+
+        auto n2 = Node::create<testtype_node_type>(random_string());
+        n2.id(specific_id);
+        std::optional<uint64_t> r2 = G.insert_node_with_id(n2);
+        REQUIRE_FALSE(r2.has_value());
+    }
+
+    SECTION("Insert a node with empty name generates a name") {
+        uint64_t specific_id = 7000;
+        auto n = Node::create<testtype_node_type>("");
+        n.id(specific_id);
+        std::optional<uint64_t> r = G.insert_node_with_id(n);
+        REQUIRE(r.has_value());
+        std::optional<Node> retrieved = G.get_node(specific_id);
+        REQUIRE(retrieved.has_value());
+        REQUIRE_FALSE(retrieved->name().empty());
+    }
+
+    SECTION("Insert a node with a duplicate name generates a new name") {
+        auto shared_name = random_string();
+        uint64_t id1 = 8000, id2 = 8001;
+
+        auto n1 = Node::create<testtype_node_type>(shared_name);
+        n1.id(id1);
+        std::optional<uint64_t> r1 = G.insert_node_with_id(n1);
+        REQUIRE(r1.has_value());
+
+        auto n2 = Node::create<testtype_node_type>(shared_name);
+        n2.id(id2);
+        std::optional<uint64_t> r2 = G.insert_node_with_id(n2);
+        REQUIRE(r2.has_value());
+
+        std::optional<Node> retrieved = G.get_node(id2);
+        REQUIRE(retrieved.has_value());
+        REQUIRE(retrieved->name() != shared_name);
+    }
+}
+
+
+TEST_CASE("Node creation",
           "[Node]") {