assert(cnode->has_parent_tracker());
if (node->is_pending()) {
auto &n = node->get_stable_for_key(i->get_key());
- assert(cnode->get_parent_node().get() == &n);
+ assert(cnode->peek_parent_node().get() == &n);
auto pos = n.lower_bound(i->get_key()).get_offset();
assert(pos < n.get_size());
assert(n.children[pos] == cnode.get());
} else {
- assert(cnode->get_parent_node().get() == node.get());
+ assert(cnode->peek_parent_node().get() == node.get());
assert(node->children[i->get_offset()] == cnode.get());
}
} else if (child_node->is_pending()) {
assert(prior.is_parent_valid());
if (node->is_mutation_pending()) {
auto &n = node->get_stable_for_key(i->get_key());
- assert(prior.get_parent_node().get() == &n);
+ assert(prior.peek_parent_node().get() == &n);
auto pos = n.lower_bound(i->get_key()).get_offset();
assert(pos < n.get_size());
assert(n.children[pos] == &prior);
} else {
- assert(prior.get_parent_node().get() == node.get());
+ assert(prior.peek_parent_node().get() == node.get());
assert(node->children[i->get_offset()] == &prior);
}
} else {
} else {
auto c = static_cast<child_node_t*>(child);
assert(c->has_parent_tracker());
- assert(c->get_parent_node().get() == node.get()
+ assert(c->peek_parent_node().get() == node.get()
|| (node->is_pending() && c->is_stable()
- && c->get_parent_node().get() == &node->get_stable_for_key(
+ && c->peek_parent_node().get() == &node->get_stable_for_key(
i->get_key())));
}
} else {
}
assert(!nextent ||
(nextent->has_parent_tracker() &&
- nextent->get_parent_node().get() == iter.get_leaf_node().get()));
+ nextent->peek_parent_node().get() == iter.get_leaf_node().get()));
return update_mapping_ret_bare_t(iter.get_cursor(c));
});
}
bool is_parent_valid() const {
return parent_tracker && parent_tracker->is_valid();
}
- TCachedExtentRef<ParentT> get_parent_node() const {
+ // this method should only be used for asserts and logs, because
+ // the parent node might be stable writing and should "wait_io"
+ // before further access
+ TCachedExtentRef<ParentT> peek_parent_node() const {
assert(parent_tracker);
return parent_tracker->get_parent();
}
assert(!down_cast().is_btree_root());
assert(this->has_parent_tracker());
auto off = get_parent_pos();
- auto parent = this->get_parent_node();
+ auto parent = this->peek_parent_node();
assert(parent->children[off] == &down_cast());
parent->children[off] = nullptr;
}
this->parent_tracker = prior.BaseChildNode<ParentT, key_t>::parent_tracker;
assert(this->has_parent_tracker());
auto off = get_parent_pos();
- auto parent = this->get_parent_node();
+ auto parent = this->peek_parent_node();
assert(me.get_prior_instance().get() ==
dynamic_cast<CachedExtent*>(parent->children[off]));
parent->children[off] = &me;
btreenode_pos_t get_parent_pos() const {
auto &me = down_cast();
- auto parent = this->get_parent_node();
+ auto parent = this->peek_parent_node();
assert(parent);
//TODO: can this search be avoided?
auto key = me.get_begin();
<< ", end=" << get_end();
}
if (this->child_node_t::is_parent_valid())
- return out << ", parent=" << (void*)this->child_node_t::get_parent_node().get();
+ return out << ", parent=" << (void*)this->child_node_t::peek_parent_node().get();
else
return out;
}