// edges: if height > 0 {
// [Box<Node<K, V, height - 1>>; 2 * B]
// } else { () },
-// parent: *const Node<K, V, height + 1>,
+// parent: Option<NonNull<Node<K, V, height + 1>>>,
// parent_idx: u16,
// len: u16,
// }
/// The underlying representation of leaf nodes.
#[repr(C)]
struct LeafNode<K, V> {
- /// We use `*const` as opposed to `*mut` so as to be covariant in `K` and `V`.
- /// This either points to an actual node or is null.
- parent: *const InternalNode<K, V>,
+ /// We want to be covariant in `K` and `V`.
+ parent: Option<NonNull<InternalNode<K, V>>>,
/// This node's index into the parent node's `edges` array.
/// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.
// be both slightly faster and easier to track in Valgrind.
keys: MaybeUninit::uninit_array(),
vals: MaybeUninit::uninit_array(),
- parent: ptr::null(),
+ parent: None,
parent_idx: MaybeUninit::uninit(),
len: 0,
}
)
};
self.height -= 1;
- self.node_as_mut().as_leaf_mut().parent = ptr::null();
+ self.node_as_mut().as_leaf_mut().parent = None;
unsafe {
Global.dealloc(NonNull::from(top).cast(), Layout::new::<InternalNode<K, V>>());
pub fn len(&self) -> usize {
// Crucially, we only access the `len` field here. If BorrowType is marker::ValMut,
// there might be outstanding mutable references to values that we must not invalidate.
- unsafe { (*self.as_leaf_ptr()).len as usize }
+ unsafe { usize::from((*self.as_leaf_ptr()).len) }
}
/// Returns the height of this node in the whole tree. Zero height denotes the
) -> Result<Handle<NodeRef<BorrowType, K, V, marker::Internal>, marker::Edge>, Self> {
// We need to use raw pointers to nodes because, if BorrowType is marker::ValMut,
// there might be outstanding mutable references to values that we must not invalidate.
- let parent_as_leaf = unsafe { (*self.as_leaf_ptr()).parent as *const LeafNode<K, V> };
- if let Some(non_zero) = NonNull::new(parent_as_leaf as *mut _) {
- Ok(Handle {
- node: NodeRef { height: self.height + 1, node: non_zero, _marker: PhantomData },
- idx: unsafe { usize::from(*(*self.as_leaf_ptr()).parent_idx.as_ptr()) },
+ let leaf_ptr = self.as_leaf_ptr();
+ unsafe { (*leaf_ptr).parent }
+ .as_ref()
+ .map(|parent| Handle {
+ node: NodeRef {
+ height: self.height + 1,
+ node: parent.cast(),
+ _marker: PhantomData,
+ },
+ idx: unsafe { usize::from((*leaf_ptr).parent_idx.assume_init()) },
_marker: PhantomData,
})
- } else {
- Err(self)
- }
+ .ok_or(self)
}
pub fn first_edge(self) -> Handle<Self, marker::Edge> {
/// Adds a key/value pair to the end of the node.
pub fn push(&mut self, key: K, val: V) {
let len = &mut self.as_leaf_mut().len;
- let idx = *len as usize;
+ let idx = usize::from(*len);
assert!(idx < CAPACITY);
*len += 1;
unsafe {
assert!(edge.height == self.height - 1);
let len = &mut self.as_leaf_mut().len;
- let idx = *len as usize;
+ let idx = usize::from(*len);
assert!(idx < CAPACITY);
*len += 1;
unsafe {
let edge =
ptr::read(internal.as_internal().edges.get_unchecked(idx + 1).as_ptr());
let mut new_root = Root { node: edge, height: internal.height - 1 };
- new_root.node_as_mut().as_leaf_mut().parent = ptr::null();
+ new_root.node_as_mut().as_leaf_mut().parent = None;
Some(new_root)
}
};
);
let mut new_root = Root { node: edge, height: internal.height - 1 };
- new_root.node_as_mut().as_leaf_mut().parent = ptr::null();
+ new_root.node_as_mut().as_leaf_mut().parent = None;
for i in 0..old_len {
Handle::new_edge(internal.reborrow_mut(), i).correct_parent_link();
/// when the ordering of edges has been changed, such as in the various `insert` methods.
fn correct_parent_link(mut self) {
let idx = self.idx as u16;
- let ptr = self.node.as_internal_mut() as *mut _;
+ let ptr = NonNull::new(self.node.as_internal_mut());
let mut child = self.descend();
child.as_leaf_mut().parent = ptr;
child.as_leaf_mut().parent_idx.write(idx);