Address PR 32 review comments (#34)

Copilot · achamayou · Copilot · web-flow · commit 75f0c11fb236 · 2026-06-08T16:22:54.000+01:00
* Address review comment fixes

* Fix clang-tidy move helper warning

* Use clear() safely after move transfer

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI &lt;175728472+Copilot@users.noreply.github.com&gt;

* test: cover tree copy assignment

---------

Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
Co-authored-by: Amaury Chamayou &lt;amaury@xargs.fr&gt;
Co-authored-by: Copilot Autofix powered by AI &lt;175728472+Copilot@users.noreply.github.com&gt;
diff --git a/merklecpp.h b/merklecpp.h
@@ -15,6 +15,7 @@
 #include <sstream>
 #include <stack>
 #include <stdexcept>
+#include <utility>
 #include <vector>
 
 #ifdef HAVE_OPENSSL
@@ -747,22 +748,9 @@ namespace merkle
 
     /// @brief Moves a tree
     /// @param other Tree to move
-    TreeT(TreeT&& other) noexcept :
-      leaf_nodes(std::move(other.leaf_nodes)),
-      uninserted_leaf_nodes(std::move(other.uninserted_leaf_nodes)),
-      _root(std::move(other._root)),
-      num_flushed(other.num_flushed),
-      insertion_stack(std::move(other.insertion_stack)),
-      hashing_stack(std::move(other.hashing_stack)),
-      walk_stack(std::move(other.walk_stack))
-    {
-      other.leaf_nodes.clear();
-      other.uninserted_leaf_nodes.clear();
-      other._root = nullptr;
-      other.num_flushed = 0;
-      other.insertion_stack.clear();
-      other.hashing_stack.clear();
-      other.walk_stack.clear();
+    TreeT(TreeT&& other) noexcept
+    {
+      move_from(other);
     }
 
     /// @brief Deserialises a tree
@@ -790,11 +778,7 @@ namespace merkle
     /// @brief Deconstructor
     ~TreeT()
     {
-      delete (_root);
-      for (auto n : uninserted_leaf_nodes)
-      {
-        delete (n);
-      }
+      clear();
     }
 
     /// @brief Invariant of the tree
@@ -981,17 +965,7 @@ namespace merkle
       {
         return *this;
       }
-      leaf_nodes.clear();
-      for (auto n : uninserted_leaf_nodes)
-      {
-        delete (n);
-      }
-      uninserted_leaf_nodes.clear();
-      insertion_stack.clear();
-      hashing_stack.clear();
-      walk_stack.clear();
-      delete (_root);
-      _root = nullptr;
+      clear();
 
       size_t to_skip = (other.num_flushed % 2 == 0) ? 0 : 1;
       _root = Node::copy_node(
@@ -1020,33 +994,8 @@ namespace merkle
         return *this;
       }
 
-      leaf_nodes.clear();
-      for (auto n : uninserted_leaf_nodes)
-      {
-        delete (n);
-      }
-      uninserted_leaf_nodes.clear();
-      insertion_stack.clear();
-      hashing_stack.clear();
-      walk_stack.clear();
-      delete (_root);
-      _root = nullptr;
-
-      leaf_nodes = std::move(other.leaf_nodes);
-      uninserted_leaf_nodes = std::move(other.uninserted_leaf_nodes);
-      _root = other._root;
-      num_flushed = other.num_flushed;
-      insertion_stack = std::move(other.insertion_stack);
-      hashing_stack = std::move(other.hashing_stack);
-      walk_stack = std::move(other.walk_stack);
-
-      other.leaf_nodes.clear();
-      other.uninserted_leaf_nodes.clear();
-      other._root = nullptr;
-      other.num_flushed = 0;
-      other.insertion_stack.clear();
-      other.hashing_stack.clear();
-      other.walk_stack.clear();
+      clear();
+      move_from(other);
       return *this;
     }
 
@@ -1468,17 +1417,7 @@ namespace merkle
     {
       MERKLECPP_TRACE(MERKLECPP_TOUT << "> deserialise " << std::endl;);
 
-      delete (_root);
-      leaf_nodes.clear();
-      for (auto n : uninserted_leaf_nodes)
-      {
-        delete (n);
-      }
-      uninserted_leaf_nodes.clear();
-      insertion_stack.clear();
-      hashing_stack.clear();
-      walk_stack.clear();
-      _root = nullptr;
+      clear();
 
       size_t num_leaf_nodes = deserialise_uint64_t(bytes, position);
       num_flushed = deserialise_uint64_t(bytes, position);
@@ -1770,15 +1709,40 @@ namespace merkle
   protected:
     void validate_partial_range(size_t from, size_t to) const
     {
-      const bool from_out_of_range = from < min_index() || max_index() < from;
-      const bool to_out_of_range = to < min_index() || max_index() < to;
-      const bool reversed_range = from > to;
-      if (empty() || from_out_of_range || to_out_of_range || reversed_range)
+      if (
+        empty() || !(min_index() <= from && from <= to && to <= max_index()))
       {
         throw std::runtime_error("invalid leaf indices");
       }
     }
 
+    void clear()
+    {
+      leaf_nodes.clear();
+      for (auto n : uninserted_leaf_nodes)
+      {
+        delete (n);
+      }
+      uninserted_leaf_nodes.clear();
+      insertion_stack.clear();
+      hashing_stack.clear();
+      walk_stack.clear();
+      delete (_root);
+      _root = nullptr;
+      num_flushed = 0;
+    }
+
+    void move_from(TreeT& other) noexcept
+    {
+      leaf_nodes = std::exchange(other.leaf_nodes, {});
+      uninserted_leaf_nodes = std::exchange(other.uninserted_leaf_nodes, {});
+      _root = std::exchange(other._root, nullptr);
+      num_flushed = std::exchange(other.num_flushed, 0);
+      insertion_stack = std::exchange(other.insertion_stack, {});
+      hashing_stack = std::exchange(other.hashing_stack, {});
+      walk_stack = std::exchange(other.walk_stack, {});
+    }
+
     /// @brief Vector of leaf nodes current in the tree
     std::vector<Node*> leaf_nodes;
 
diff --git a/test/coverage.cpp b/test/coverage.cpp
@@ -265,6 +265,15 @@ namespace
     const auto expected_min = source.min_index();
     const auto expected_max = source.max_index();
 
+    merkle::Tree copy_assigned(hash_with_byte(0xEE));
+    copy_assigned = source;
+    require(copy_assigned.root() == expected_root, "copy assignment root mismatch");
+    require(copy_assigned.min_index() == expected_min, "copy assignment min mismatch");
+    require(copy_assigned.max_index() == expected_max, "copy assignment max mismatch");
+    require(
+      copy_assigned.leaf(expected_min) == source_hashes[expected_min],
+      "copy-assigned leaf mismatch");
+
     merkle::Tree moved(std::move(source));
     require(moved.root() == expected_root, "move constructor root mismatch");
     require(moved.min_index() == expected_min, "move constructor min mismatch");
@@ -307,12 +316,12 @@ int main()
   }
   catch (const std::exception& ex)
   {
-    std::cout << "Error: " << ex.what() << '\n';
+    std::cerr << "Error: " << ex.what() << '\n';
     return 1;
   }
   catch (...)
   {
-    std::cout << "Error" << '\n';
+    std::cerr << "Error" << '\n';
     return 1;
   }
 

Original file line number	Diff line number	Diff line change
`@@ -265,6 +265,15 @@ namespace`
`265`	`265`	`const auto expected_min = source.min_index();`
`266`	`266`	`const auto expected_max = source.max_index();`
`267`	`267`
	`268`	`+ merkle::Tree copy_assigned(hash_with_byte(0xEE));`
	`269`	`+ copy_assigned = source;`
	`270`	`+ require(copy_assigned.root() == expected_root, "copy assignment root mismatch");`
	`271`	`+ require(copy_assigned.min_index() == expected_min, "copy assignment min mismatch");`
	`272`	`+ require(copy_assigned.max_index() == expected_max, "copy assignment max mismatch");`
	`273`	`+ require(`
	`274`	`+ copy_assigned.leaf(expected_min) == source_hashes[expected_min],`
	`275`	`+ "copy-assigned leaf mismatch");`
	`276`	`+`
`268`	`277`	`merkle::Tree moved(std::move(source));`
`269`	`278`	`require(moved.root() == expected_root, "move constructor root mismatch");`
`270`	`279`	`require(moved.min_index() == expected_min, "move constructor min mismatch");`
`@@ -307,12 +316,12 @@ int main()`
`307`	`316`	`}`
`308`	`317`	`catch (const std::exception& ex)`
`309`	`318`	`{`
`310`		`- std::cout << "Error: " << ex.what() << '\n';`
	`319`	`+ std::cerr << "Error: " << ex.what() << '\n';`
`311`	`320`	`return 1;`
`312`	`321`	`}`
`313`	`322`	`catch (...)`
`314`	`323`	`{`
`315`		`- std::cout << "Error" << '\n';`
	`324`	`+ std::cerr << "Error" << '\n';`
`316`	`325`	`return 1;`
`317`	`326`	`}`
`318`	`327`