Simplify node_item_ref and free_blocks_extent_ref (#67)

src/eptree.cpp

@@ -27,7 +27,7 @@ bool EPTree::insert(const iterator::value_type& key_value) {
     auto depth = node_level->tree_header()->depth.value();
     // Where to split the level
     auto split_point = node_level->middle();
-    key_type split_point_key = (*split_point).key;
+    key_type split_point_key = (*split_point).key();
     // Alloc new right side tree
     auto right_block_number = AllocBlockForTree(node_level->tree_header()->block_number.value(), allocated_extents);
     RTree new_right(allocator_->LoadAllocatorBlock(right_block_number, /*new_block=*/true));
@@ -112,7 +112,7 @@ EPTree::iterator EPTree::begin() const {
   assert(tree_header()->depth.value() >= 1);
   for (int i = 0; i < tree_header()->depth.value(); i++) {
     assert(i == 0 || !nodes.back().iterator.is_end());
-    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*nodes.back().iterator).value)};
+    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*nodes.back().iterator).value())};
     node.iterator = node.node->begin();
     nodes.push_back(std::move(node));
   }
@@ -125,7 +125,7 @@ EPTree::iterator EPTree::end() const {
   assert(tree_header()->depth.value() >= 1);
   for (int i = 0; i < tree_header()->depth.value(); i++) {
     assert(i == 0 || !nodes.back().iterator.is_begin());
-    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*--nodes.back().iterator).value)};
+    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*--nodes.back().iterator).value())};
     node.iterator = node.node->end();
     nodes.push_back(std::move(node));
   }
@@ -137,7 +137,7 @@ EPTree::iterator EPTree::find(key_type key, bool exact_match) const {
   nodes.reserve(tree_header()->depth.value());
   for (int i = 0; i < tree_header()->depth.value(); i++) {
     assert(i == 0 || !nodes.back().iterator.is_end());
-    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*nodes.back().iterator).value)};
+    iterator::node_info node{i == 0 ? block() : allocator_->LoadAllocatorBlock((*nodes.back().iterator).value())};
     node.iterator = node.node->find(key, exact_match && i + 1 == tree_header()->depth.value());
     nodes.push_back(std::move(node));
   }

src/eptree_iterator.cpp

@@ -19,11 +19,11 @@ EPTreeIterator& EPTreeIterator::operator++() {
       return *this;  // end
     }
   }
-  uint32_t node_block_number = (*rnode->iterator).value;
+  uint32_t node_block_number = (*rnode->iterator).value();
   for (auto node = rnode.base(); node != nodes_.end(); ++node) {
     *node = {allocator_->LoadAllocatorBlock(node_block_number)};
     node->iterator = node->node->begin();
-    node_block_number = (*node->iterator).value;
+    node_block_number = (*node->iterator).value();
   }
   return *this;
 }
@@ -35,11 +35,11 @@ EPTreeIterator& EPTreeIterator::operator--() {
     if (rnode == nodes_.rend())
       return *this;  // begin
   }
-  uint32_t node_block_number = (*--rnode->iterator).value;
+  uint32_t node_block_number = (*--rnode->iterator).value();
   for (auto node = rnode.base(); node != nodes_.end(); ++node) {
     *node = {allocator_->LoadAllocatorBlock(node_block_number)};
     node->iterator = node->node->end();
-    node_block_number = (*--node->iterator).value;
+    node_block_number = (*--node->iterator).value();
   }
   return *this;
 }

src/free_blocks_allocator.cpp

@@ -212,7 +212,7 @@ void FreeBlocksAllocator::AddFreeBlocksForSize(FreeBlocksRangeInfo range, size_t
            sub_range.blocks_count / size_blocks_count <= 0x10);
     auto new_value = static_cast<nibble>(sub_range.blocks_count / size_blocks_count - 1);
     if (join_before && sub_range.block_number == range_in_size.block_number) {
-      (*join_before_iter).value = new_value;
+      (*join_before_iter).set_value(new_value);
     } else {
       // Don't use pos to insert because:
       // 1. Our find may go back so it isn't the exact location to insert it.
@@ -284,9 +284,9 @@ void FreeBlocksAllocator::RecreateEPTreeIfNeeded() {
     return;
   }
   auto last = eptree.end()--;
-  if ((*last).key || (*last).value != 2)
+  if ((*last).key() || (*last).value() != 2)
     return;
-  uint32_t last_value = (*last).value;
+  uint32_t last_value = (*last).value();
   assert(last_value == 2);
   std::vector<FreeBlocksRangeInfo> blocks_to_delete;
   // eptree is empty (aka have only initial FTreee), resize it to one eptree

src/free_blocks_allocator.h

@@ -33,6 +33,11 @@ struct FreeBlocksExtentInfo {
   size_t bucket_index;
 
   uint32_t end_block_number() const { return block_number + blocks_count; }
+
+  bool operator==(const FreeBlocksExtentInfo& other) const {
+    return block_number == other.block_number && blocks_count == other.blocks_count &&
+           bucket_index == other.bucket_index;
+  }
 };
 
 struct FreeBlocksRangeInfo {

src/free_blocks_tree.cpp

@@ -11,7 +11,7 @@ FreeBlocksTree::iterator FreeBlocksTree::begin() const {
   iterator::eptree_node_info eptree{{allocator_}};
   eptree.iterator = eptree.node->begin();
   assert(!eptree.iterator.is_end());
-  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value)}};
+  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value())}};
   ftrees.iterator = ftrees.node->begin();
   while (ftrees.iterator.is_end()) {
     if ((++eptree.iterator).is_end()) {
@@ -20,7 +20,7 @@ FreeBlocksTree::iterator FreeBlocksTree::begin() const {
       return {allocator_, std::move(eptree), std::move(ftrees)};
     }
 
-    ftrees = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value)}};
+    ftrees = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value())}};
     ftrees.iterator = ftrees.node->begin();
   }
   return {allocator_, std::move(eptree), std::move(ftrees)};
@@ -31,7 +31,7 @@ FreeBlocksTree::iterator FreeBlocksTree::end() const {
   eptree.iterator = eptree.node->end();
   assert(!eptree.iterator.is_begin());
   --eptree.iterator;  // EPTree size should always be >= 1
-  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value)}};
+  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value())}};
   ftrees.iterator = ftrees.node->end();
   return {allocator_, std::move(eptree), std::move(ftrees)};
 }
@@ -41,9 +41,9 @@ FreeBlocksTree::iterator FreeBlocksTree::find(key_type key, bool exact_match) co
   eptree.iterator = eptree.node->find(key, false);
   if (eptree.iterator.is_end())
     return end();
-  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value)}};
+  iterator::ftrees_node_info ftrees{{allocator_->LoadAllocatorBlock((*eptree.iterator).value())}};
   ftrees.iterator = ftrees.node->find(key, exact_match);
-  if (!ftrees.iterator.is_end() && key >= (*ftrees.iterator).key) {
+  if (!ftrees.iterator.is_end() && key >= (*ftrees.iterator).key()) {
     return {allocator_, std::move(eptree), std::move(ftrees)};
   }
   // If FTrees is empty or our key is smaller than the first key, go to previous node with value
@@ -57,7 +57,7 @@ FreeBlocksTree::iterator FreeBlocksTree::find(key_type key, bool exact_match) co
   auto orig_eptree_it = eptree.iterator;
   // Go backward to search for value
   while (!eptree.iterator.is_begin()) {
-    iterator::ftrees_node_info nftrees{{allocator_->LoadAllocatorBlock((*--eptree.iterator).value)}};
+    iterator::ftrees_node_info nftrees{{allocator_->LoadAllocatorBlock((*--eptree.iterator).value())}};
     nftrees.iterator = nftrees.node->find(key, exact_match);
     if (!nftrees.iterator.is_end()) {
       ftrees = std::move(nftrees);
@@ -71,7 +71,7 @@ FreeBlocksTree::iterator FreeBlocksTree::find(key_type key, bool exact_match) co
   }
   // Go forward to search..
   while (!(++eptree.iterator).is_end()) {
-    ftrees = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value)}};
+    ftrees = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value())}};
     ftrees.iterator = ftrees.node->begin();
     if (!ftrees.iterator.is_end()) {
       // Found value

src/free_blocks_tree_bucket.cpp

@@ -11,7 +11,7 @@
 
 bool FreeBlocksTreeBucket::insert(FTree::iterator::value_type key_val) {
   auto pos = find_for_insert(key_val.key);
-  if (!pos.is_end() && (*pos).key == key_val.key) {
+  if (!pos.is_end() && (*pos).key() == key_val.key) {
     // already in tree
     return false;
   }
@@ -26,7 +26,7 @@ bool FreeBlocksTreeBucket::insert(iterator& pos, FTree::iterator::value_type key
   auto old_block = pos.ftree().node->block();
   old_block->Detach();
   FTrees old_ftrees{old_block};
-  uint32_t left_block_number = (*pos.eptree().iterator).value;
+  uint32_t left_block_number = (*pos.eptree().iterator).value();
   auto left_block = allocator_->LoadAllocatorBlock(left_block_number, true);
   assert(left_block->device_block_number() == old_block->device_block_number());
 
@@ -37,7 +37,7 @@ bool FreeBlocksTreeBucket::insert(iterator& pos, FTree::iterator::value_type key
     for (const auto& ftree : old_ftrees.ftrees()) {
       if (ftree.size() > 0) {
         auto first = ftree.begin();
-        *allocated_extent = {(*first).key, 1, ftree.index()};
+        *allocated_extent = {(*first).key(), 1, ftree.index()};
         break;
       }
     }
@@ -67,12 +67,12 @@ bool FreeBlocksTreeBucket::insert(iterator& pos, FTree::iterator::value_type key
 void FreeBlocksTreeBucket::erase(iterator pos, std::vector<FreeBlocksRangeInfo>& blocks_to_delete) {
   pos.ftree().node->erase(pos.ftree().iterator);
   // Check for FTrees deletion, we never delete the first FTree (key zero)
-  if (!pos.ftree().node->empty() || !(*pos.eptree().iterator).key) {
+  if (!pos.ftree().node->empty() || !(*pos.eptree().iterator).key()) {
     return;
   }
   if (FTrees(pos.ftree().node->block()).empty()) {
     // The FTree is the first block for deletion
-    blocks_to_delete.push_back({(*pos.eptree().iterator).value, 1});
+    blocks_to_delete.push_back({(*pos.eptree().iterator).value(), 1});
     pos.eptree().node->erase(pos.eptree().iterator, blocks_to_delete);
   }
 }
@@ -89,7 +89,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::begin() const {
   iterator::eptree_node_info eptree{{allocator_}};
   eptree.iterator = eptree.node->begin();
   assert(!eptree.iterator.is_end());
-  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
   ftree.iterator = ftree.node->begin();
   while (ftree.iterator.is_end()) {
     if ((++eptree.iterator).is_end()) {
@@ -98,7 +98,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::begin() const {
       return {allocator_, block_size_index_, std::move(eptree), std::move(ftree)};
     }
 
-    ftree = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+    ftree = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
     ftree.iterator = ftree.node->begin();
   }
   return {allocator_, block_size_index_, std::move(eptree), std::move(ftree)};
@@ -109,7 +109,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::end() const {
   eptree.iterator = eptree.node->end();
   assert(!eptree.iterator.is_begin());
   --eptree.iterator;  // EPTree size should always be >= 1
-  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
   ftree.iterator = ftree.node->end();
   return {allocator_, block_size_index_, std::move(eptree), std::move(ftree)};
 }
@@ -119,9 +119,9 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::find(key_type key, bool exa
   eptree.iterator = eptree.node->find(key, false);
   if (exact_match && eptree.iterator.is_end())
     return end();
-  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
   ftree.iterator = ftree.node->find(key, exact_match);
-  if (!ftree.iterator.is_end() && key >= (*ftree.iterator).key) {
+  if (!ftree.iterator.is_end() && key >= (*ftree.iterator).key()) {
     return {allocator_, block_size_index_, std::move(eptree), std::move(ftree)};
   }
   // If FTree is empty or our key is smaller than the first key, go to previous node with value
@@ -134,7 +134,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::find(key_type key, bool exa
   auto orig_eptree_it = eptree.iterator;
   // Go backward to search for value
   while (!eptree.iterator.is_begin()) {
-    iterator::ftree_node_info nftree{{allocator_->LoadAllocatorBlock((*--eptree.iterator).value), block_size_index_}};
+    iterator::ftree_node_info nftree{{allocator_->LoadAllocatorBlock((*--eptree.iterator).value()), block_size_index_}};
     nftree.iterator = nftree.node->end();
     if (!nftree.iterator.is_begin()) {
       --nftree.iterator;
@@ -149,7 +149,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::find(key_type key, bool exa
   }
   // Go forward to search..
   while (!(++eptree.iterator).is_end()) {
-    ftree = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+    ftree = {{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
     ftree.iterator = ftree.node->begin();
     if (!ftree.iterator.is_end()) {
       // Found value
@@ -164,7 +164,7 @@ FreeBlocksTreeBucket::iterator FreeBlocksTreeBucket::find_for_insert(key_type ke
   iterator::eptree_node_info eptree{{allocator_}};
   eptree.iterator = eptree.node->find(key, false);
   assert(!eptree.iterator.is_end());
-  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value), block_size_index_}};
+  iterator::ftree_node_info ftree{{allocator_->LoadAllocatorBlock((*eptree.iterator).value()), block_size_index_}};
   ftree.iterator = ftree.node->find(key, false);
   return {allocator_, block_size_index_, std::move(eptree), std::move(ftree)};
 }

src/free_blocks_tree_bucket_iterator.cpp

@@ -16,7 +16,7 @@ FreeBlocksTreeBucketIterator& FreeBlocksTreeBucketIterator::operator++() {
       return *this;  // end
     }
 
-    ftree_ = {{allocator_->LoadAllocatorBlock((*eptree_.iterator).value), block_size_index_}};
+    ftree_ = {{allocator_->LoadAllocatorBlock((*eptree_.iterator).value()), block_size_index_}};
     ftree_.iterator = ftree_.node->begin();
   }
   return *this;
@@ -29,7 +29,7 @@ FreeBlocksTreeBucketIterator& FreeBlocksTreeBucketIterator::operator--() {
       return *this;  // begin
     }
 
-    ftree_ = {{allocator_->LoadAllocatorBlock((*--eptree_.iterator).value), block_size_index_}};
+    ftree_ = {{allocator_->LoadAllocatorBlock((*--eptree_.iterator).value()), block_size_index_}};
     ftree_.iterator = ftree_.node->end();
   }
   --ftree_.iterator;

src/free_blocks_tree_bucket_iterator.h

@@ -36,7 +36,7 @@ class FreeBlocksTreeBucketIterator {
         eptree_(std::move(eptree)),
         ftree_(std::move(ftree)) {}
 
-  reference operator*() const { return {(*ftree_.iterator)._base}; }
+  reference operator*() const { return {*ftree_.iterator, block_size_index_}; }
 
   FreeBlocksTreeBucketIterator& operator++();
   FreeBlocksTreeBucketIterator& operator--();

src/free_blocks_tree_iterator.cpp

@@ -17,7 +17,7 @@ FreeBlocksTreeIterator& FreeBlocksTreeIterator::operator++() {
       return *this;  // end
     }
 
-    ftrees_ = {allocator_->LoadAllocatorBlock((*eptree_.iterator).value)};
+    ftrees_ = {allocator_->LoadAllocatorBlock((*eptree_.iterator).value())};
     ftrees_.iterator = ftrees_.node->begin();
   }
   return *this;
@@ -31,7 +31,7 @@ FreeBlocksTreeIterator& FreeBlocksTreeIterator::operator--() {
       return *this;  // begin
     }
 
-    ftrees_ = {allocator_->LoadAllocatorBlock((*--eptree_.iterator).value)};
+    ftrees_ = {allocator_->LoadAllocatorBlock((*--eptree_.iterator).value())};
     ftrees_.iterator = ftrees_.node->end();
   }
   --ftrees_.iterator;

src/free_blocks_tree_iterator.h

@@ -22,7 +22,7 @@ class FreeBlocksTreeIterator {
   using value_type = typename FTrees::iterator::value_type;
   using ref_type = typename FTrees::iterator::ref_type;
 
-  using reference = value_type;
+  using reference = ref_type;
 
   using eptree_node_info = node_iterator_info<EPTree>;
   using ftrees_node_info = node_iterator_info<FTrees>;

src/ftree.cpp

@@ -29,6 +29,6 @@ PTreeNode<FTreeLeaf_details>::iterator split_point(const PTreeNode<FTreeLeaf_det
       res = node.begin() + 4;
       break;
   }
-  split_key = (*res).key;
+  split_key = (*res).key();
   return res;
 }

src/ftree.h

@@ -33,8 +33,6 @@ class FTree : public PTree<PTreeNode_details, FTreeLeaf_details, FTreesBlockArgs
 
   size_t index() const { return block_size_index_; }
 
-  uint16_t extra_info() const override { return static_cast<uint16_t>(block_size_index_); }
-
  private:
   size_t block_size_index_;
 };

src/ftrees.cpp

@@ -12,10 +12,10 @@ void FTrees::split(FTrees& left, FTrees& right, key_type& split_point_key) {
   auto max_ftree_it = std::ranges::max_element(ftrees_, [](const FTree& a, const FTree& b) {
     return a.header()->items_count.value() < b.header()->items_count.value();
   });
-  split_point_key = (*max_ftree_it->middle()).key;
+  split_point_key = (*max_ftree_it->middle()).key();
   for (auto [old_ftree, left_ftree, right_ftree] : std::views::zip(ftrees_, left.ftrees_, right.ftrees_)) {
     auto pos = old_ftree.find(split_point_key, false);
-    if (!pos.is_end() && (*pos).key < split_point_key)
+    if (!pos.is_end() && (*pos).key() < split_point_key)
       ++pos;
     old_ftree.split_compact(left_ftree, right_ftree, pos);
   }
@@ -56,12 +56,12 @@ FTrees::iterator FTrees::find(key_type key, bool exact_match) const {
                  });
   size_t index = 0;
   if (exact_match && !std::ranges::any_of(ftrees_info, [key](const iterator::ftree_info& ftree) {
-        return !ftree.iterator.is_end() && (*ftree.iterator).key == key;
+        return !ftree.iterator.is_end() && (*ftree.iterator).key() == key;
       })) {
     return end();
   }
   auto before_keys = ftrees_info | std::views::filter([key](const iterator::ftree_info& ftree) {
-                       return !ftree.iterator.is_end() && (*ftree.iterator).key <= key;
+                       return !ftree.iterator.is_end() && (*ftree.iterator).key() <= key;
                      });
   if (!std::ranges::empty(before_keys)) {
     // take max key before or key
@@ -73,7 +73,7 @@ FTrees::iterator FTrees::find(key_type key, bool exact_match) const {
     }
   } else {
     auto after_keys = ftrees_info | std::views::filter([key](const iterator::ftree_info& ftree) {
-                        return !ftree.iterator.is_end() && (*ftree.iterator).key > key;
+                        return !ftree.iterator.is_end() && (*ftree.iterator).key() > key;
                       });
     if (!std::ranges::empty(after_keys)) {
       index = iterator::find_next_extent_index(after_keys, /*max=*/false);