Fix LocalVocab merge

src/engine/LocalVocab.cpp

@@ -7,6 +7,7 @@
 #include "absl/strings/str_cat.h"
 #include "global/Id.h"
 #include "global/ValueId.h"
+#include "util/BlankNodeManager.h"
 
 // _____________________________________________________________________________
 LocalVocab LocalVocab::clone() const {
@@ -84,7 +85,9 @@ BlankNodeIndex LocalVocab::getBlankNodeIndex(
   AD_CONTRACT_CHECK(blankNodeManager);
   // Initialize the `localBlankNodeManager_` if it doesn't exist yet.
   if (!localBlankNodeManager_) [[unlikely]] {
-    localBlankNodeManager_.emplace(blankNodeManager);
+    localBlankNodeManager_ =
+        std::make_shared<ad_utility::BlankNodeManager::LocalBlankNodeManager>(
+            blankNodeManager);
   }
   return BlankNodeIndex::make(localBlankNodeManager_->getId());
 }

src/engine/LocalVocab.h

@@ -4,8 +4,10 @@
 
 #pragma once
 
+#include <algorithm>
 #include <cstdlib>
 #include <memory>
+#include <ranges>
 #include <span>
 #include <string>
 #include <vector>
@@ -39,7 +41,7 @@ class LocalVocab {
   auto& primaryWordSet() { return *primaryWordSet_; }
   const auto& primaryWordSet() const { return *primaryWordSet_; }
 
-  std::optional<ad_utility::BlankNodeManager::LocalBlankNodeManager>
+  std::shared_ptr<ad_utility::BlankNodeManager::LocalBlankNodeManager>
       localBlankNodeManager_;
 
  public:
@@ -100,6 +102,27 @@ class LocalVocab {
       std::ranges::copy(vocab.otherWordSets_, inserter);
       *inserter = vocab.primaryWordSet_;
     }
+
+    // Also merge the `vocabs` `LocalBlankNodeManager`s, if they exist.
+    using LocalBlankNodeManager =
+        ad_utility::BlankNodeManager::LocalBlankNodeManager;
+    if (auto it = std::ranges::find_if(
+            vocabs,
+            [](const LocalVocab& vocab) -> bool {
+              return vocab.localBlankNodeManager_.get() != nullptr;
+            });
+        it != vocabs.end()) {
+      if (!localBlankNodeManager_) {
+        localBlankNodeManager_ = std::make_shared<LocalBlankNodeManager>(
+            (*it).localBlankNodeManager_->blankNodeManager_);
+      }
+      localBlankNodeManager_->mergeWith(
+          vocabs | std::views::transform(
+                       [](const LocalVocab& vocab)
+                           -> std::shared_ptr<const LocalBlankNodeManager> {
+                         return vocab.localBlankNodeManager_;
+                       }));
+    }
   }
 
   // Return all the words from all the word sets as a vector.

src/util/BlankNodeManager.cpp

@@ -4,6 +4,8 @@
 
 #include "util/BlankNodeManager.h"
 
+#include "util/Exception.h"
+
 namespace ad_utility {
 
 // _____________________________________________________________________________
@@ -62,9 +64,18 @@ uint64_t BlankNodeManager::LocalBlankNodeManager::getId() {
 // _____________________________________________________________________________
 bool BlankNodeManager::LocalBlankNodeManager::containsBlankNodeIndex(
     uint64_t index) const {
-  return std::ranges::any_of(blocks_, [index](const Block& block) {
+  auto containsIndex = [index](const Block& block) {
     return index >= block.startIdx_ && index < block.nextIdx_;
-  });
+  };
+  auto otherBlocks = std::views::join(
+      otherManagers_ |
+      std::views::transform(
+          [](const std::shared_ptr<const LocalBlankNodeManager>& l) {
+            return l->blocks_;
+          }));
+
+  return std::ranges::any_of(blocks_, containsIndex) ||
+         std::ranges::any_of(otherBlocks, containsIndex);
 }
 
 }  // namespace ad_utility

src/util/BlankNodeManager.h

@@ -87,16 +87,30 @@ class BlankNodeManager {
     // Return true iff the `index` was returned by a previous call to `getId()`.
     bool containsBlankNodeIndex(uint64_t index) const;
 
-   private:
-    // Reserved blocks.
-    std::vector<BlankNodeManager::Block> blocks_;
+    // Merge passed `LocalBlankNodeManager`s to keep alive their reserved
+    // BlankNodeIndex blocks.
+    template <std::ranges::range R>
+    void mergeWith(const R& localBlankNodeManagers) {
+      std::ranges::copy_if(
+          localBlankNodeManagers, std::back_inserter(otherManagers_),
+          [](const std::shared_ptr<const LocalBlankNodeManager>& l) -> bool {
+            return l.get() != nullptr;
+          });
+    }
 
     // Reference to the BlankNodeManager, used to free the reserved blocks.
     BlankNodeManager* blankNodeManager_;
 
+   private:
+    // Reserved blocks.
+    std::vector<BlankNodeManager::Block> blocks_;
+
     // The first index after the current Block.
     uint64_t idxAfterCurrentBlock_{0};
 
+    // Other LocalBlankNodeManagers merged into this instance.
+    std::vector<std::shared_ptr<const LocalBlankNodeManager>> otherManagers_;
+
     FRIEND_TEST(BlankNodeManager, LocalBlankNodeManagerGetID);
   };
 

test/LocalVocabTest.cpp

@@ -162,6 +162,24 @@ TEST(LocalVocab, merge) {
   EXPECT_EQ(*indices[1], lit("twoA"));
   EXPECT_EQ(*indices[2], lit("oneB"));
   EXPECT_EQ(*indices[3], lit("twoB"));
+
+  // Test that the `LocalBlankNodeManager` of vocabs is merged correctly.
+  LocalVocab vocC, vocD;
+  ad_utility::BlankNodeManager bnm;
+  auto id = vocC.getBlankNodeIndex(&bnm);
+  auto vocabs2 = std::vector{&std::as_const(vocC), &std::as_const(vocD)};
+  LocalVocab localVocabMerged2 = LocalVocab::merge(vocabs2);
+  localVocabMerged2.isBlankNodeIndexContained(id);
+
+  LocalVocab vocE, vocF;
+  auto id2 = vocE.getBlankNodeIndex(&bnm);
+  auto vocabs3 =
+      std::vector{&std::as_const(localVocabMerged2), &std::as_const(vocF)};
+  vocE.mergeWith(vocabs3 | std::views::transform(
+                               [](const LocalVocab* l) -> const LocalVocab& {
+                                 return *l;
+                               }));
+  vocE.isBlankNodeIndexContained(id2);
 }
 
 // _____________________________________________________________________________