Refactor the implementation

src/borrow.rs

@@ -0,0 +1,28 @@
+use core::{marker::PhantomData, ptr::NonNull};
+
+pub(super) struct DormantMutRef<'a, T> {
+    ptr: NonNull<T>,
+    _marker: PhantomData<&'a mut T>,
+}
+
+impl<'a, T> DormantMutRef<'a, T> {
+    pub fn new(val: &'a mut T) -> (&'a mut T, DormantMutRef<'a, T>) {
+        let mut ptr = NonNull::from(val);
+        let new_val = unsafe { ptr.as_mut() };
+        (
+            new_val,
+            DormantMutRef {
+                ptr,
+                _marker: PhantomData,
+            },
+        )
+    }
+
+    pub unsafe fn awaken(mut self) -> &'a mut T {
+        unsafe { self.ptr.as_mut() }
+    }
+
+    pub unsafe fn reborrow(&mut self) -> &'a mut T {
+        unsafe { self.ptr.as_mut() }
+    }
+}

src/cow.rs

@@ -1,28 +0,0 @@
-use crate::entry::{ItemEntry, XEntry};
-use crate::lock::XLock;
-use crate::node::deep_copy_node_entry;
-
-/// The COW trait provides the capability for Copy-On-Write (COW) behavior to XEntries with Clone ability.
-pub(super) trait Cow<I: ItemEntry, L: XLock> {
-    /// Check if the target entry that is about to be operated on need to perform COW.
-    /// If the target entry is subject to a mutable operation and is shared with other XArrays,
-    /// perform the COW and return the copied XEntry with `Some()`, else return `None`.
-    fn copy_if_shared(&self) -> Option<XEntry<I, L>>;
-}
-
-impl<I: ItemEntry, L: XLock> Cow<I, L> for XEntry<I, L> {
-    default fn copy_if_shared(&self) -> Option<XEntry<I, L>> {
-        None
-    }
-}
-
-impl<I: ItemEntry + Clone, L: XLock> Cow<I, L> for XEntry<I, L> {
-    fn copy_if_shared(&self) -> Option<XEntry<I, L>> {
-        if self.is_node() && self.node_strong_count().unwrap() > 1 {
-            let new_entry = deep_copy_node_entry(self);
-            Some(new_entry)
-        } else {
-            None
-        }
-    }
-}

src/cursor.rs

@@ -1,61 +1,176 @@
 use core::marker::PhantomData;
-use core::ops::Deref;
 
 use smallvec::SmallVec;
 
-use crate::entry::{ItemEntry, ItemRef, XEntry};
-use crate::lock::XLock;
+use crate::borrow::DormantMutRef;
+use crate::entry::{ItemEntry, ItemRef, NodeMaybeMut, XEntry};
 use crate::mark::XMark;
-use crate::node::{Height, ReadOnly, ReadWrite, XNode};
+use crate::node::XNode;
 use crate::xarray::{XArray, MAX_HEIGHT, SLOT_SIZE};
 
+trait Operation {}
+
+struct ReadOnly {}
+struct ReadWrite {}
+
+impl Operation for ReadOnly {}
+impl Operation for ReadWrite {}
+
 /// CursorState represents the current state of the cursor. Currently, there are two possible states:
 /// 1. inactive: the state where the cursor is not positioned on any node.
 /// 2. positioned on a node: this state includes information about the node the cursor is on,
 /// as well as the offset of the entry that needs to be operated on within the slots of the current node.
-enum CursorState<'a, I, L, Operation>
+enum CursorState<'a, I, O>
 where
     I: ItemEntry,
-    L: XLock,
+    O: Operation,
 {
-    Inactive,
+    Inactive(PhantomData<O>),
     AtNode {
-        node: &'a XNode<I, L, Operation>,
+        node: &'a XNode<I>,
+        operation_offset: u8,
+    },
+    AtNodeMut {
+        node: &'a mut XNode<I>,
         operation_offset: u8,
     },
 }
 
-impl<'a, I: ItemEntry, L: XLock, Operation> CursorState<'a, I, L, Operation> {
+impl<'a, I: ItemEntry, O: Operation> Default for CursorState<'a, I, O> {
     fn default() -> Self {
-        Self::Inactive
+        Self::Inactive(PhantomData)
     }
+}
 
-    fn arrive_node(&mut self, node: &'a XNode<I, L, Operation>, operation_offset: u8) {
+impl<'a, I: ItemEntry, O: Operation> CursorState<'a, I, O> {
+    fn move_to(&mut self, node: &'a XNode<I>, index: u64) {
+        let operation_offset = node.entry_offset(index);
         *self = Self::AtNode {
             node,
             operation_offset,
         };
     }
+}
 
-    fn is_at_node(&self) -> bool {
-        matches!(
-            self,
+impl<'a, I: ItemEntry> CursorState<'a, I, ReadWrite> {
+    fn move_to_mut(&mut self, node: &'a mut XNode<I>, index: u64) {
+        let operation_offset = node.entry_offset(index);
+        *self = Self::AtNodeMut {
+            node,
+            operation_offset,
+        };
+    }
+
+    fn move_to_maybe_mut(&mut self, node: NodeMaybeMut<'a, I>, index: u64) {
+        match node {
+            NodeMaybeMut::Shared(node) => self.move_to(node, index),
+            NodeMaybeMut::Exclusive(node) => self.move_to_mut(node, index),
+        }
+    }
+}
+
+impl<'a, I: ItemEntry, O: Operation> CursorState<'a, I, O> {
+    fn into_node(self) -> Option<(&'a XNode<I>, u8)> {
+        match self {
             Self::AtNode {
-                node: _,
-                operation_offset: _
-            }
-        )
+                node,
+                operation_offset,
+            } => Some((node, operation_offset)),
+            Self::AtNodeMut {
+                node,
+                operation_offset,
+            } => Some((node, operation_offset)),
+            Self::Inactive(..) => None,
+        }
     }
+}
 
-    fn node_info(&self) -> Option<(&'a XNode<I, L, Operation>, u8)> {
-        if let Self::AtNode {
-            node,
-            operation_offset,
-        } = self
-        {
-            Some((node, *operation_offset))
-        } else {
-            None
+impl<'a, I: ItemEntry> CursorState<'a, I, ReadWrite> {
+    fn into_node_mut(self) -> Option<(&'a mut XNode<I>, u8)> {
+        match self {
+            Self::AtNodeMut {
+                node,
+                operation_offset,
+            } => Some((node, operation_offset)),
+            Self::Inactive(..) | Self::AtNode { .. } => None,
+        }
+    }
+
+    fn into_node_maybe_mut(self) -> Option<(NodeMaybeMut<'a, I>, u8)> {
+        match self {
+            Self::AtNode {
+                node,
+                operation_offset,
+            } => Some((NodeMaybeMut::Shared(node), operation_offset)),
+            Self::AtNodeMut {
+                node,
+                operation_offset,
+            } => Some((NodeMaybeMut::Exclusive(node), operation_offset)),
+            Self::Inactive(..) => None,
+        }
+    }
+}
+
+impl<'a, I: ItemEntry> CursorState<'a, I, ReadOnly> {
+    fn as_node(&self) -> Option<(&'a XNode<I>, u8)> {
+        match self {
+            Self::AtNode {
+                node,
+                operation_offset,
+            } => Some((*node, *operation_offset)),
+            Self::Inactive(..) | Self::AtNodeMut { .. } => None,
+        }
+    }
+}
+
+impl<'a, I: ItemEntry> CursorState<'a, I, ReadWrite> {
+    fn as_node(&self) -> Option<(&XNode<I>, u8)> {
+        match self {
+            Self::AtNode {
+                node,
+                operation_offset,
+            } => Some((*node, *operation_offset)),
+            Self::AtNodeMut {
+                node,
+                operation_offset,
+            } => Some((*node, *operation_offset)),
+            Self::Inactive(..) => None,
+        }
+    }
+
+    fn as_node_mut(&mut self) -> Option<(&mut XNode<I>, u8)> {
+        match self {
+            Self::AtNodeMut {
+                node,
+                operation_offset,
+            } => Some((*node, *operation_offset)),
+            Self::Inactive(..) | Self::AtNode { .. } => None,
+        }
+    }
+}
+
+impl<'a, I: ItemEntry, O: Operation> CursorState<'a, I, O> {
+    fn is_at_node(&self) -> bool {
+        match self {
+            Self::AtNode { .. } | Self::AtNodeMut { .. } => true,
+            Self::Inactive(..) => false,
+        }
+    }
+
+    fn is_leaf(&self) -> bool {
+        match self {
+            Self::AtNodeMut { node, .. } => node.is_leaf(),
+            Self::AtNode { node, .. } => node.is_leaf(),
+            Self::Inactive(..) => false,
+        }
+    }
+}
+
+impl<'a, I: ItemEntry> CursorState<'a, I, ReadWrite> {
+    fn is_at_node_mut(&self) -> bool {
+        match self {
+            Self::AtNodeMut { .. } => true,
+            Self::Inactive(..) | Self::AtNode { .. } => false,
         }
     }
 }
@@ -80,179 +195,164 @@ impl<'a, I: ItemEntry, L: XLock, Operation> CursorState<'a, I, L, Operation> {
 /// thereby assisting it in performing some operations that involve searching upwards.
 ///
 /// Multiple Cursors are allowed to operate on a single XArray at the same time.
-pub struct Cursor<'a, I, L, M>
+pub struct Cursor<'a, I, M>
 where
     I: ItemEntry,
-    L: XLock,
     M: Into<XMark>,
 {
     /// The `XArray` the cursor located in.
-    xa: &'a XArray<I, L, M>,
+    xa: &'a XArray<I, M>,
     /// The target index of the cursor in the belonged `XArray`.
     index: u64,
     /// Represents the current state of the cursor.
-    state: CursorState<'a, I, L, ReadOnly>,
+    state: CursorState<'a, I, ReadOnly>,
     /// Record add nodes passed from the head node to the target position.
     /// The index is the height of the recorded node.
-    ancestors: SmallVec<[&'a XNode<I, L, ReadOnly>; MAX_HEIGHT]>,
-
-    _marker: PhantomData<I>,
+    ancestors: SmallVec<[&'a XNode<I>; MAX_HEIGHT]>,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> Cursor<'a, I, L, M> {
+impl<'a, I: ItemEntry, M: Into<XMark>> Cursor<'a, I, M> {
     /// Create an `Cursor` to perform read related operations on the `XArray`.
-    pub(super) fn new(xa: &'a XArray<I, L, M>, index: u64) -> Self {
+    pub(super) fn new(xa: &'a XArray<I, M>, index: u64) -> Self {
         let mut cursor = Self {
             xa,
             index,
             state: CursorState::default(),
             ancestors: SmallVec::new(),
-            _marker: PhantomData,
         };
-
         cursor.traverse_to_target();
-        cursor
-    }
-
-    /// Get a reference to current operated entry of the Cursor.
-    fn ref_operated_entry(&self) -> Option<&'a XEntry<I, L>> {
-        // SAFETY: The lifetime of the reference to the operated XEntry is `'a`,
-        // during which there will not be another mut reference to the belonged xarray,
-        // nor will there be any modification operations on the XNode where it resides.
-        self.state
-            .node_info()
-            .map(|info| unsafe { info.0.ref_node_entry(info.1) })
-    }
 
-    /// Move the `Cursor` to the `XNode`, and update the cursor's state based on its target index.
-    /// Return a reference to the `XEntry` within the slots of the current XNode that needs to be operated on.
-    fn move_to(&mut self, node: &'a XNode<I, L, ReadOnly>) -> &'a XEntry<I, L> {
-        let offset = node.entry_offset(self.index);
-        self.state.arrive_node(node, offset);
-        self.ref_operated_entry().unwrap()
+        cursor
     }
 
     /// Reset the target index of the Cursor. Once set, it will immediately attempt to move the Cursor
     ///  to touch the target XEntry.
     pub fn reset_to(&mut self, index: u64) {
-        self.init();
+        self.reset();
         self.index = index;
+
         self.traverse_to_target();
     }
 
+    /// Return the target index of the cursor.
+    pub fn index(&self) -> u64 {
+        self.index
+    }
+
     /// Move the target index of the cursor to index + 1.
     /// If the target index's corresponding XEntry is not within the current XNode, the cursor will
     /// move to touch the target XEntry. If the move fails, the cursor's state will be set to `Inactive`.
     pub fn next(&mut self) {
-        // TODO: overflow;
-        self.index += 1;
-        if !self.is_arrived() {
-            return;
-        }
+        self.index = self.index.checked_add(1).unwrap();
 
-        if self.xa.max_index() < self.index {
-            self.init();
+        if !self.state.is_at_node() {
             return;
         }
 
-        let (mut current_node, mut operation_offset) = self.state.node_info().unwrap();
+        let (mut current_node, mut operation_offset) =
+            core::mem::take(&mut self.state).into_node().unwrap();
+
         operation_offset += 1;
         while operation_offset == SLOT_SIZE as u8 {
-            operation_offset = current_node.offset_in_parent() + 1;
-            if let Some(node) = self.ancestors.pop() {
-                current_node = node;
-                continue;
-            }
-
-            operation_offset = 0;
-            break;
-        }
-        self.state.arrive_node(current_node, operation_offset);
-
-        while !current_node.is_leaf() {
-            let next_entry = self.ref_operated_entry().unwrap();
-            if !next_entry.is_node() {
-                self.init();
+            let Some(parent_node) = self.ancestors.pop() else {
+                self.reset();
                 return;
-            }
+            };
 
-            let next_node = next_entry.as_node().unwrap();
-            self.ancestors.push(current_node);
-            self.move_to(next_node);
-            current_node = next_node;
+            operation_offset = current_node.offset_in_parent() + 1;
+            current_node = parent_node;
         }
-    }
 
-    /// Judge if the target item is marked with the input `mark`.
-    /// If target item does not exist, the function will return `None`.
-    pub fn is_marked(&self, mark: M) -> bool {
-        if let Some((current_node, operation_offset)) = self.state.node_info() {
-            current_node.is_marked(operation_offset, mark.into().index())
-        } else {
-            false
-        }
+        self.state.move_to(current_node, self.index);
+        self.continue_traverse_to_target();
     }
 
     /// Load the `XEntry` at the current cursor index within the `XArray`.
     ///
     /// Returns a reference to the `XEntry` at the target index if succeed.
     /// If the cursor cannot reach to the target index, the method will return `None`.
-    pub fn load(&self) -> Option<ItemRef<'a, I>> {
-        if let Some(entry) = self.ref_operated_entry() {
-            entry.as_item_ref()
-        } else {
-            None
-        }
+    pub fn load(&mut self) -> Option<ItemRef<'a, I>> {
+        self.traverse_to_target();
+        self.state
+            .as_node()
+            .and_then(|(node, off)| node.entry(off).as_item_ref())
+    }
+
+    /// Judge if the target item is marked with the input `mark`.
+    /// If target item does not exist, the function will return `None`.
+    pub fn is_marked(&mut self, mark: M) -> bool {
+        self.traverse_to_target();
+        self.state
+            .as_node()
+            .map(|(node, off)| node.is_marked(off, mark.into().index()))
+            .unwrap_or(false)
     }
 
     /// Traverse the XArray and move to the node that can operate the target entry.
     /// It then returns the reference to the `XEntry` stored in the slot corresponding to the target index.
     /// A target operated XEntry must be an item entry.
     /// If can not touch the target entry, the function will return `None`.
-    fn traverse_to_target(&mut self) -> Option<&'a XEntry<I, L>> {
-        if self.is_arrived() {
-            return self.ref_operated_entry();
+    fn traverse_to_target(&mut self) {
+        if self.state.is_at_node() {
+            return;
         }
 
         let max_index = self.xa.max_index();
         if max_index < self.index || max_index == 0 {
-            return None;
+            return;
         }
-        self.move_to(self.xa.head().as_node().unwrap());
 
-        let (mut current_node, _) = self.state.node_info().unwrap();
-        let mut operated_entry = self.ref_operated_entry().unwrap();
-        while !current_node.is_leaf() {
+        let current_node = self.xa.head().as_node_ref().unwrap();
+        self.state.move_to(current_node, self.index);
+        self.continue_traverse_to_target();
+    }
+
+    fn continue_traverse_to_target(&mut self) {
+        while !self.state.is_leaf() {
+            let (current_node, operation_offset) =
+                core::mem::take(&mut self.state).into_node().unwrap();
+
+            let operated_entry = current_node.entry(operation_offset);
             if !operated_entry.is_node() {
-                self.init();
-                return None;
+                self.reset();
+                return;
             }
+
             self.ancestors.push(current_node);
 
-            current_node = operated_entry.as_node().unwrap();
-            operated_entry = self.move_to(current_node);
+            let new_node = operated_entry.as_node_ref().unwrap();
+            self.state.move_to(new_node, self.index);
         }
-        Some(operated_entry)
     }
 
     /// Initialize the Cursor to its initial state.
-    pub fn init(&mut self) {
+    fn reset(&mut self) {
         self.state = CursorState::default();
-        self.ancestors = SmallVec::new();
+        self.ancestors.clear();
     }
+}
 
-    /// Return the target index of the cursor.
-    pub fn index(&self) -> u64 {
-        self.index
+struct NodeMutRef<'a, I>
+where
+    I: ItemEntry,
+{
+    inner: DormantMutRef<'a, XNode<I>>,
+}
+
+impl<'a, I: ItemEntry> NodeMutRef<'a, I> {
+    fn new(node: &'a mut XNode<I>, operation_offset: u8) -> (&'a mut XEntry<I>, NodeMutRef<'a, I>) {
+        let (node, inner) = DormantMutRef::new(node);
+        (node.entry_mut(operation_offset), NodeMutRef { inner })
+    }
+
+    unsafe fn awaken(self) -> &'a mut XNode<I> {
+        self.inner.awaken()
     }
 
-    /// Determine whether the cursor arrive at the node that can operate target entry.
-    /// It can only be used before or after traversing. Since the cursor will only either
-    /// not yet started or has already reached the target node when not in a traversal,
-    /// it is reasonable to determine whether the cursor has reached its destination node
-    /// by checking if the cursor is positioned on a node.
-    pub fn is_arrived(&self) -> bool {
-        self.state.is_at_node()
+    unsafe fn awaken_modified(self, last_index: u64) -> (&'a mut XNode<I>, bool) {
+        let node = unsafe { self.inner.awaken() };
+        let changed = node.update_mark(node.height().height_offset(last_index));
+        (node, changed)
     }
 }
 
@@ -290,115 +390,50 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> Cursor<'a, I, L, M> {
 ///
 /// When a CursorMut doing write operation on XArray, it should not be affected by other CursorMuts
 /// or affect other Cursors.
-pub struct CursorMut<'a, I, L, M>
+pub struct CursorMut<'a, I, M>
 where
     I: ItemEntry,
-    L: XLock,
     M: Into<XMark>,
 {
     /// The `XArray` the cursor located in.
-    xa: &'a mut XArray<I, L, M>,
+    xa: DormantMutRef<'a, XArray<I, M>>,
     /// The target index of the cursor in the belonged `XArray`.
     index: u64,
     /// Represents the current state of the cursor.
-    state: CursorState<'a, I, L, ReadWrite>,
+    state: CursorState<'a, I, ReadWrite>,
     /// Record add nodes passed from the head node to the target position.
     /// The index is the height of the recorded node.
-    ancestors: SmallVec<[&'a XNode<I, L, ReadWrite>; MAX_HEIGHT]>,
-
-    is_exclusive: bool,
-
-    _marker: PhantomData<I>,
+    mut_ancestors: SmallVec<[NodeMutRef<'a, I>; MAX_HEIGHT]>,
+    ancestors: SmallVec<[&'a XNode<I>; MAX_HEIGHT]>,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, M> {
+impl<'a, I: ItemEntry, M: Into<XMark>> CursorMut<'a, I, M> {
     /// Create an `CursorMut` to perform read and write operations on the `XArray`.
-    pub(super) fn new(xa: &'a mut XArray<I, L, M>, index: u64) -> Self {
+    pub(super) fn new(xa: &'a mut XArray<I, M>, index: u64) -> Self {
         let mut cursor = Self {
-            xa,
+            xa: DormantMutRef::new(xa).1,
             index,
             state: CursorState::default(),
+            mut_ancestors: SmallVec::new(),
             ancestors: SmallVec::new(),
-            is_exclusive: false,
-            _marker: PhantomData,
         };
-
         cursor.traverse_to_target();
-        cursor
-    }
-
-    /// Get a reference to current operated entry of the CursorMut.
-    fn ref_operated_entry(&self) -> Option<&'a XEntry<I, L>> {
-        // SAFETY: The lifetime of the reference to the operated XEntry is equal to `&self`.
-        // Hence when the reference existing there will not be other mutable operation in current `CursorMut`,
-        // nor will there be any modification operations on the XNode where it resides.
-        self.state
-            .node_info()
-            .map(|info| unsafe { info.0.ref_node_entry(self.is_exclusive, info.1) })
-    }
-
-    /// Reborrow the target node with a longer lifetime `'a`.
-    ///
-    /// # Safety
-    ///
-    /// Users must ensure when this reborrowed reference exists, its corresponding XNode will not be removed.
-    pub(super) unsafe fn reborrow_node<Operation>(
-        &self,
-        node: &XNode<I, L, Operation>,
-    ) -> &'a XNode<I, L, Operation> {
-        &*(node as *const XNode<I, L, Operation>)
-    }
 
-    /// Move the `CursorMut` to the `XNode`, and update the cursor's state based on its target index.
-    /// Return a reference to the `XEntry` within the slots of the current XNode that needs to be operated on next.
-    fn move_to(&mut self, node: &'a XNode<I, L, ReadWrite>) -> &XEntry<I, L> {
-        let offset = node.entry_offset(self.index);
-        self.state.arrive_node(node, offset);
-        self.ref_operated_entry().unwrap()
-    }
-
-    /// Initialize the Cursor to its initial state.
-    pub fn init(&mut self) {
-        self.state = CursorState::default();
-        self.ancestors = SmallVec::new();
-        self.is_exclusive = false;
+        cursor
     }
 
     /// Reset the target index of the Cursor. Once set, it will immediately attempt to move the
     /// Cursor to touch the target XEntry.
     pub fn reset_to(&mut self, index: u64) {
-        self.init();
+        self.reset();
         self.index = index;
-        self.traverse_to_target();
-    }
 
-    /// Load the `XEntry` at the current cursor index within the `XArray`.
-    ///
-    /// Returns a reference to the `XEntry` at the target index if succeed.
-    /// If the cursor cannot reach to the target index, the method will return `None`.
-    pub fn load(&self) -> Option<ItemRef<'a, I>> {
-        if let Some(entry) = self.ref_operated_entry() {
-            entry.as_item_ref()
-        } else {
-            None
-        }
+        self.traverse_to_target();
     }
 
-    /// Stores the provided `XEntry` in the `XArray` at the position indicated by the current cursor index.
-    ///
-    /// If the provided entry is the same as the current entry at the cursor position,
-    /// the method returns the provided entry without making changes.
-    /// Otherwise, it replaces the current entry with the provided one and returns the old entry.
-    pub fn store(&mut self, item: I) -> Option<I> {
-        self.ensure_exclusive_before_modify();
-        let stored_entry = XEntry::from_item(item);
-        let target_entry = self.expand_and_traverse_to_target();
-        if stored_entry.raw() == target_entry.raw() {
-            return XEntry::into_item(stored_entry);
-        }
-        let (current_node, operation_offset) = self.state.node_info().unwrap();
-        let old_entry = current_node.set_entry(operation_offset, stored_entry);
-        XEntry::into_item(old_entry)
+    /// Return the target index of the cursor.
+    pub fn index(&self) -> u64 {
+        self.index
     }
 
     /// Move the target index of the cursor to index + 1.
@@ -406,46 +441,80 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, M> {
     /// will move to touch the target XEntry. If the move fails, the cursor's state will be
     /// set to `Inactive`.
     pub fn next(&mut self) {
-        // TODO: overflow;
-        self.index += 1;
-        self.is_exclusive = false;
-        if !self.is_arrived() {
-            return;
-        }
+        self.index = self.index.checked_add(1).unwrap();
 
-        if self.xa.max_index() < self.index {
-            self.init();
+        if !self.state.is_at_node() {
             return;
         }
 
-        let (mut current_node, mut operation_offset) = self.state.node_info().unwrap();
+        let (mut current_node, mut operation_offset) = core::mem::take(&mut self.state)
+            .into_node_maybe_mut()
+            .unwrap();
+
         operation_offset += 1;
         while operation_offset == SLOT_SIZE as u8 {
-            operation_offset = current_node.offset_in_parent() + 1;
-            if let Some(node) = self.ancestors.pop() {
-                current_node = node;
-                continue;
-            }
+            let offset_in_parent = current_node.offset_in_parent();
+            drop(current_node);
+
+            let parent_node = if let Some(node) = self.ancestors.pop() {
+                NodeMaybeMut::Shared(node)
+            } else if let Some(node) = self.mut_ancestors.pop() {
+                NodeMaybeMut::Exclusive(unsafe { node.awaken_modified(self.index - 1).0 })
+            } else {
+                self.reset();
+                return;
+            };
 
-            operation_offset = 0;
-            break;
+            operation_offset = offset_in_parent + 1;
+            current_node = parent_node;
         }
-        self.state.arrive_node(current_node, operation_offset);
 
-        while !current_node.is_leaf() {
-            self.ancestors.push(current_node);
-            let next_entry = self.ref_operated_entry().unwrap();
-            if !next_entry.is_node() {
-                self.init();
-                return;
-            }
+        self.state.move_to_maybe_mut(current_node, self.index);
+        self.continue_traverse_to_target();
+    }
 
-            // SAFETY: Cursor will move to the `next_node` and the current XNode will not be
-            // removed within this function.
-            let next_node = unsafe { self.reborrow_node(next_entry.as_node_mut().unwrap()) };
-            self.move_to(next_node);
-            (current_node, _) = self.state.node_info().unwrap();
-        }
+    /// Load the `XEntry` at the current cursor index within the `XArray`.
+    ///
+    /// Returns a reference to the `XEntry` at the target index if succeed.
+    /// If the cursor cannot reach to the target index, the method will return `None`.
+    pub fn load(&mut self) -> Option<ItemRef<'_, I>> {
+        self.traverse_to_target();
+        self.state
+            .as_node()
+            .and_then(|(node, off)| node.entry(off).as_item_ref())
+    }
+
+    /// Judge if the target item is marked with the input `mark`.
+    /// If target item does not exist, the function will return `None`.
+    pub fn is_marked(&mut self, mark: M) -> bool {
+        self.traverse_to_target();
+        self.state
+            .as_node()
+            .map(|(node, off)| node.is_marked(off, mark.into().index()))
+            .unwrap_or(false)
+    }
+
+    /// Stores the provided `XEntry` in the `XArray` at the position indicated by the current cursor index.
+    ///
+    /// If the provided entry is the same as the current entry at the cursor position,
+    /// the method returns the provided entry without making changes.
+    /// Otherwise, it replaces the current entry with the provided one and returns the old entry.
+    pub fn store(&mut self, item: I) -> Option<I> {
+        self.expand_and_traverse_to_target();
+        self.state
+            .as_node_mut()
+            .and_then(|(node, off)| node.set_entry(off, XEntry::from_item(item)).into_item())
+    }
+
+    /// Removes the `XEntry` at the target index of the 'CursorMut' within the `XArray`.
+    ///
+    /// This is achieved by storing an empty `XEntry` at the target index using the `store` method.
+    /// The method returns the replaced `XEntry` that was previously stored at the target index.
+    pub fn remove(&mut self) -> Option<I> {
+        self.ensure_exclusive_before_modification();
+        self.state
+            .as_node_mut()
+            .and_then(|(node, off)| node.set_entry(off, XEntry::EMPTY).into_item())
     }
 
     /// Mark the item at the target index in the `XArray` with the input `mark`.
@@ -455,28 +524,12 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, M> {
     /// with the input `mark`, because a marked intermediate node should be equivalent to
     /// having a child node that is marked.
     pub fn set_mark(&mut self, mark: M) -> Result<(), ()> {
-        self.ensure_exclusive_before_modify();
-        if let Some((current_node, operation_offset)) = self.state.node_info() {
-            let item_entry = self.ref_operated_entry().unwrap();
-            if item_entry.is_null() {
-                return Err(());
-            }
-
-            let mark_index = mark.into().index();
-            current_node.set_mark(operation_offset, mark_index);
-
-            let mut offset_in_parent = current_node.offset_in_parent();
-            for ancestor in self.ancestors.iter().rev() {
-                if ancestor.is_marked(offset_in_parent, mark_index) {
-                    break;
-                }
-                ancestor.set_mark(offset_in_parent, mark_index);
-                offset_in_parent = ancestor.offset_in_parent();
-            }
-            Ok(())
-        } else {
-            Err(())
-        }
+        self.ensure_exclusive_before_modification();
+        self.state
+            .as_node_mut()
+            .filter(|(node, off)| node.entry(*off).is_item())
+            .map(|(node, off)| node.set_mark(off, mark.into().index()))
+            .ok_or(())
     }
 
     /// Unset the input `mark` for the item at the target index in the `XArray`.
@@ -485,83 +538,33 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, M> {
     /// This operation will also unset the input `mark` for all nodes along the path from the head node
     /// to the target node if the input `mark` have not marked any of their children.
     pub fn unset_mark(&mut self, mark: M) -> Result<(), ()> {
-        self.ensure_exclusive_before_modify();
-        if let Some((current_node, operation_offset)) = self.state.node_info() {
-            let item_entry = self.ref_operated_entry().unwrap();
-            if item_entry.is_null() {
-                return Err(());
-            }
-
-            let mark_index = mark.into().index();
-            current_node.unset_mark(operation_offset, mark_index);
-
-            if current_node.is_mark_clear(mark_index) {
-                let mut offset_in_parent = current_node.offset_in_parent();
-                for ancestor in self.ancestors.iter().rev() {
-                    ancestor.unset_mark(offset_in_parent, mark_index);
-                    if !ancestor.is_mark_clear(mark_index) {
-                        break;
-                    }
-
-                    offset_in_parent = ancestor.offset_in_parent();
-                }
-            }
-            Ok(())
-        } else {
-            Err(())
-        }
-    }
-
-    /// Removes the `XEntry` at the target index of the 'CursorMut' within the `XArray`.
-    ///
-    /// This is achieved by storing an empty `XEntry` at the target index using the `store` method.
-    /// The method returns the replaced `XEntry` that was previously stored at the target index.
-    pub fn remove(&mut self) -> Option<I> {
-        self.ensure_exclusive_before_modify();
-        if let Some((current_node, operation_offset)) = self.state.node_info() {
-            let old_entry = current_node.set_entry(operation_offset, XEntry::EMPTY);
-            return XEntry::into_item(old_entry);
-        }
-        None
+        self.ensure_exclusive_before_modification();
+        self.state
+            .as_node_mut()
+            .filter(|(node, off)| node.entry(*off).is_item())
+            .map(|(node, off)| node.unset_mark(off, mark.into().index()))
+            .ok_or(())
     }
 
     /// Traverse the XArray and move to the node that can operate the target entry.
     /// It then returns the reference to the `XEntry` stored in the slot corresponding to the target index.
     /// A target operated XEntry must be an item entry.
     /// If can not touch the target entry, the function will return `None`.
-    fn traverse_to_target(&mut self) -> Option<&XEntry<I, L>> {
-        if self.is_arrived() {
-            return self.ref_operated_entry();
+    fn traverse_to_target(&mut self) {
+        if self.state.is_at_node() {
+            return;
         }
 
-        let max_index = self.xa.max_index();
-        if max_index < self.index || max_index == 0 {
-            return None;
-        }
+        let xa = unsafe { self.xa.reborrow() };
 
-        if self.is_exclusive {
-            self.xa.ensure_head_exclusive();
+        let max_index = xa.max_index();
+        if max_index < self.index || max_index == 0 {
+            return;
         }
 
-        let head = self.xa.head().as_node_mut().unwrap();
-        // SAFETY: Cursor will move to the `head` and the head will not be
-        // removed within this function.
-        self.move_to(unsafe { self.reborrow_node(head) });
-
-        let (mut current_node, _) = self.state.node_info().unwrap();
-        while !current_node.is_leaf() {
-            self.ancestors.push(current_node);
-            let operated_entry = self.ref_operated_entry().unwrap();
-            if !operated_entry.is_node() {
-                self.init();
-                return None;
-            }
-            // SAFETY: Cursor will move to the `current_node` and it will not be
-            // removed within this function.
-            current_node = unsafe { self.reborrow_node(operated_entry.as_node_mut().unwrap()) };
-            self.move_to(current_node);
-        }
-        self.ref_operated_entry()
+        let current_node = xa.head_mut().as_node_maybe_mut().unwrap();
+        self.state.move_to_maybe_mut(current_node, self.index);
+        self.continue_traverse_to_target();
     }
 
     /// Traverse the XArray and move to the node that can operate the target entry.
@@ -572,146 +575,119 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, M> {
     ///
     /// It then returns the reference to the `XEntry` stored in the slot corresponding to the target index.
     /// A target operated XEntry must be an item entry.
-    fn expand_and_traverse_to_target(&mut self) -> &XEntry<I, L> {
-        if self.is_arrived() {
-            return self.ref_operated_entry().unwrap();
+    fn expand_and_traverse_to_target(&mut self) {
+        if self.state.is_at_node() {
+            self.ensure_exclusive_before_modification();
+            return;
         }
 
-        self.expand_height();
+        let head = {
+            let xa = unsafe { self.xa.reborrow() };
+            xa.reserve(self.index);
+            xa.head_mut().as_node_mut_or_cow().unwrap()
+        };
+
+        self.state.move_to_mut(head, self.index);
+        self.exclusively_traverse_to_target();
+    }
 
-        if self.is_exclusive {
-            self.xa.ensure_head_exclusive();
+    fn ensure_exclusive_before_modification(&mut self) {
+        if self.state.is_at_node_mut() {
+            return;
         }
 
-        let head = self.xa.head().as_node_mut().unwrap();
-        // SAFETY: Cursor will move to the `head` and the head will not be
-        // removed within this function.
-        self.move_to(unsafe { self.reborrow_node(head) });
+        self.state = CursorState::default();
+        self.ancestors.clear();
 
-        let (mut current_node, _) = self.state.node_info().unwrap();
-        while !current_node.is_leaf() {
-            self.ancestors.push(current_node);
-            let mut operated_entry = self.ref_operated_entry().unwrap();
-            let current_height = current_node.height();
+        let node = match self.mut_ancestors.pop() {
+            Some(node) => unsafe { node.awaken() },
+            None => {
+                let xa = unsafe { self.xa.reborrow() };
 
-            if !operated_entry.is_node() {
-                let (current_node, operation_offset) = self.state.node_info().unwrap();
-                let new_owned_entry =
-                    self.alloc_node(Height::new(*current_height - 1), operation_offset);
-                let _ = current_node.set_entry(operation_offset, new_owned_entry);
-                // SAFETY: The cursor will move towards the subtree of the current_node,
-                // and no further modifications will be made to the current_node within the current function.
-                operated_entry =
-                    unsafe { current_node.ref_node_entry(self.is_exclusive, operation_offset) };
+                let head = xa.head_mut();
+                if !head.is_node() {
+                    return;
+                }
+
+                head.as_node_mut_or_cow().unwrap()
             }
-            // SAFETY: Cursor will move to the `current_node` and it will not be
-            // removed within this function.
-            current_node = unsafe { self.reborrow_node(operated_entry.as_node_mut().unwrap()) };
+        };
 
-            self.move_to(current_node);
-        }
-        self.ref_operated_entry().unwrap()
+        self.state.move_to_mut(node, self.index);
+        self.exclusively_traverse_to_target();
     }
 
-    /// Increase the number of heights for XArray to expand its capacity, allowing it to accommodate
-    /// the target index, and returns the height of the final head node.
-    ///
-    /// If the head node of the XArray does not exist, allocate a new head node of appropriate height
-    /// directly. Otherwise, if needed, repeatedly insert new nodes on top of the current head node to
-    /// serve as the new head.
-    fn expand_height(&mut self) -> Height {
-        if self.xa.head().is_null() {
-            let mut head_height = Height::new(1);
-            while self.index > head_height.max_index() {
-                *head_height += 1;
-            }
-            let head = self.alloc_node(head_height, 0);
-            self.xa.set_head(head);
-            return head_height;
-        } else {
-            loop {
-                let head_height = {
-                    if self.is_exclusive {
-                        self.xa.ensure_head_exclusive();
+    fn continue_traverse_to_target(&mut self) {
+        while !self.state.is_leaf() {
+            let (current_node, operation_offset) = core::mem::take(&mut self.state)
+                .into_node_maybe_mut()
+                .unwrap();
+
+            let next_node = match current_node {
+                NodeMaybeMut::Shared(node) => {
+                    let operated_entry = node.entry(operation_offset);
+                    if !operated_entry.is_node() {
+                        self.reset();
+                        return;
                     }
-                    let head = self.xa.head().as_node().unwrap();
-                    head.height()
-                };
 
-                if head_height.max_index() > self.index {
-                    return head_height;
-                }
+                    self.ancestors.push(node);
 
-                let new_node_entry = self.alloc_node(Height::new(*head_height + 1), 0);
-                let old_head_entry = self.xa.set_head(new_node_entry);
-                let old_head = old_head_entry.as_node_mut().unwrap();
-                let new_head = self.xa.head().as_node_mut().unwrap();
-                for i in 0..3 {
-                    if !old_head.mark(i).is_clear() {
-                        new_head.set_mark(0, i);
+                    NodeMaybeMut::Shared(operated_entry.as_node_ref().unwrap())
+                }
+                NodeMaybeMut::Exclusive(node) => {
+                    let (operated_entry, dormant_node) = NodeMutRef::new(node, operation_offset);
+                    if !operated_entry.is_node() {
+                        self.reset();
+                        return;
                     }
+
+                    self.mut_ancestors.push(dormant_node);
+
+                    operated_entry.as_node_maybe_mut().unwrap()
                 }
-                let _empty = new_head.set_entry(0, old_head_entry);
-            }
+            };
+
+            self.state.move_to_maybe_mut(next_node, self.index);
         }
     }
 
-    /// Allocate a new XNode with the specified height and offset,
-    /// then generate a node entry from it and return it to the caller.
-    fn alloc_node(&mut self, height: Height, offset: u8) -> XEntry<I, L> {
-        XEntry::from_node(XNode::<I, L, ReadWrite>::new(height, offset))
-    }
+    fn exclusively_traverse_to_target(&mut self) {
+        while !self.state.is_leaf() {
+            let (current_node, operation_offset) =
+                core::mem::take(&mut self.state).into_node_mut().unwrap();
 
-    fn ensure_exclusive_before_modify(&mut self) {
-        if self.is_exclusive {
-            return;
-        }
+            if current_node.entry(operation_offset).is_null() {
+                let new_node = XNode::new(current_node.height().go_leaf(), operation_offset);
+                let new_entry = XEntry::from_node(new_node);
+                current_node.set_entry(operation_offset, new_entry);
+            }
 
-        if !self.is_arrived() {
-            self.is_exclusive = true;
-            return;
-        }
+            let (operated_entry, dormant_node) = NodeMutRef::new(current_node, operation_offset);
+            self.mut_ancestors.push(dormant_node);
 
-        if self.xa.head().node_strong_count().unwrap() > 1 {
-            self.init();
-            self.is_exclusive = true;
-            self.traverse_to_target();
-            return;
+            let next_node = operated_entry.as_node_mut_or_cow().unwrap();
+            self.state.move_to_mut(next_node, self.index)
         }
+    }
+
+    /// Initialize the Cursor to its initial state.
+    fn reset(&mut self) {
+        self.state = CursorState::default();
+        self.ancestors.clear();
 
-        let mut new_ancestors: SmallVec<[&'a XNode<I, L, ReadWrite>; MAX_HEIGHT]> = SmallVec::new();
-        for ancestor in self.ancestors.iter() {
-            let offset = ancestor.entry_offset(self.index);
-            // SAFETY: The process involves descending from the top within the current ancestors to find the first shared node,
-            // without modifying the contents of the XNode.
-            let entry = unsafe { ancestor.ref_node_entry(false, offset) };
-            if entry.node_strong_count().unwrap() > 1 {
-                self.move_to(ancestor);
+        while let Some(node) = self.mut_ancestors.pop() {
+            let (_, changed) = unsafe { node.awaken_modified(self.index) };
+            if !changed {
+                self.mut_ancestors.clear();
                 break;
             }
-            new_ancestors.push(*ancestor);
-        }
-        self.ancestors = new_ancestors;
-
-        let (mut current_node, _) = self.state.node_info().unwrap();
-        self.is_exclusive = true;
-        while !current_node.is_leaf() {
-            // SAFETY: Cursor will move to the `next_node` and it will not be
-            // removed within this function.
-            let next_node = unsafe {
-                self.reborrow_node(self.ref_operated_entry().unwrap().as_node_mut().unwrap())
-            };
-            self.ancestors.push(current_node);
-            self.move_to(next_node);
-            current_node = next_node;
         }
     }
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> Deref for CursorMut<'a, I, L, M> {
-    type Target = Cursor<'a, I, L, M>;
-
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*(self as *const CursorMut<'a, I, L, M> as *const Cursor<'a, I, L, M>) }
+impl<'a, I: ItemEntry, M: Into<XMark>> Drop for CursorMut<'a, I, M> {
+    fn drop(&mut self) {
+        self.reset();
     }
 }

src/entry.rs

@@ -2,11 +2,9 @@ use alloc::boxed::Box;
 use alloc::sync::Arc;
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
-use core::ops::Deref;
+use core::ops::{Deref, Not};
 
-use crate::lock::XLock;
-use crate::node::{ReadWrite, XNode};
-use crate::xarray::SLOT_SIZE;
+use crate::node::{TryClone, XNode};
 
 /// A trait that should be implemented for the types users wish to store in an `XArray`.
 /// Items stored in an XArray are required to be 8 bytes in size, Currently it can be various pointer types.
@@ -62,8 +60,7 @@ where
     _marker: PhantomData<&'a I>,
 }
 
-impl<'a, I: ItemEntry> Deref for ItemRef<'a, I>
-{
+impl<'a, I: ItemEntry> Deref for ItemRef<'a, I> {
     type Target = I;
 
     fn deref(&self) -> &I {
@@ -83,159 +80,204 @@ impl<'a, I: ItemEntry> Deref for ItemRef<'a, I>
 /// `XEntry` have the ownership. Once it generated from an item or a XNode, the ownership of the item or the XNode
 /// will be transferred to the `XEntry`. If the stored item in the XArray implemented Clone trait, then the XEntry
 /// in the XArray can also implement Clone trait.
-#[derive(Eq, Debug)]
-pub(super) struct XEntry<I, L>
+#[derive(PartialEq, Eq, Debug)]
+#[repr(transparent)]
+pub(super) struct XEntry<I>
 where
     I: ItemEntry,
-    L: XLock,
 {
     raw: usize,
-    _marker: core::marker::PhantomData<(I, L)>,
+    _marker: core::marker::PhantomData<(Arc<XNode<I>>, I)>,
 }
 
-impl<I: ItemEntry, L: XLock> Drop for XEntry<I, L> {
-    fn drop(&mut self) {
-        if self.is_item() {
-            unsafe {
-                I::from_raw(self.raw);
-            }
-        }
-        if self.is_node() {
-            unsafe {
-                Arc::from_raw((self.raw - 2) as *const XNode<I, L>);
-            }
-        }
-    }
+#[derive(PartialEq, Eq, Debug)]
+#[repr(usize)]
+enum EntryType {
+    Node = 0,
+    Item = 2,
 }
 
-impl<I: ItemEntry + Clone, L: XLock> Clone for XEntry<I, L> {
-    fn clone(&self) -> Self {
-        if self.is_item() {
-            let cloned_entry = unsafe {
-                let item_entry = ManuallyDrop::new(I::from_raw(self.raw));
-                XEntry::from_item((*item_entry).clone())
-            };
-            cloned_entry
-        } else {
-            if self.is_node() {
-                unsafe {
-                    Arc::increment_strong_count((self.raw - 2) as *const XNode<I, L>);
-                }
-            }
-            Self {
-                raw: self.raw,
-                _marker: core::marker::PhantomData,
-            }
-        }
-    }
-}
+impl TryFrom<usize> for EntryType {
+    type Error = ();
 
-impl<I: ItemEntry, L: XLock> PartialEq for XEntry<I, L> {
-    fn eq(&self, o: &Self) -> bool {
-        self.raw == o.raw
+    fn try_from(val: usize) -> Result<Self, Self::Error> {
+        match val {
+            x if x == EntryType::Node as usize => Ok(EntryType::Node),
+            x if x == EntryType::Item as usize => Ok(EntryType::Item),
+            _ => Err(()),
+        }
     }
 }
 
-impl<'a, I: ItemEntry, L: XLock> XEntry<I, L> {
-    pub fn raw(&self) -> usize {
-        self.raw
-    }
+impl<I: ItemEntry> XEntry<I> {
+    const TYPE_MASK: usize = 3;
 
-    pub const EMPTY: Self = unsafe { Self::new(0) };
+    pub const EMPTY: Self = Self {
+        raw: 0,
+        _marker: PhantomData,
+    };
 
-    /// Create a new XEntry with the input raw value.
-    ///
-    /// # Safety
-    /// Users should ensure the input raw value is corresponding to a valid XEntry.
-    pub const unsafe fn new(raw: usize) -> Self {
+    unsafe fn new(ptr: usize, ty: EntryType) -> Self {
+        debug_assert!(ptr & Self::TYPE_MASK == 0);
         Self {
-            raw,
+            raw: ptr | (ty as usize),
             _marker: PhantomData,
         }
     }
 
+    fn ptr(&self) -> usize {
+        self.raw & !Self::TYPE_MASK
+    }
+
+    fn ty(&self) -> Option<EntryType> {
+        self.is_null()
+            .not()
+            .then(|| (self.raw & Self::TYPE_MASK).try_into().unwrap())
+    }
+
     pub fn is_null(&self) -> bool {
         self.raw == 0
     }
+}
+
+pub(super) enum NodeMaybeMut<'a, I>
+where
+    I: ItemEntry,
+{
+    Shared(&'a XNode<I>),
+    Exclusive(&'a mut XNode<I>),
+}
 
-    pub fn is_internal(&self) -> bool {
-        self.raw & 3 == 2
+impl<'a, I: ItemEntry> Deref for NodeMaybeMut<'a, I> {
+    type Target = XNode<I>;
+
+    fn deref(&self) -> &XNode<I> {
+        match &self {
+            Self::Shared(ref node) => node,
+            Self::Exclusive(ref node) => node,
+        }
     }
+}
 
-    pub fn is_item(&self) -> bool {
-        !self.is_null() && !self.is_internal()
+impl<I: ItemEntry> XEntry<I> {
+    pub fn from_node(node: XNode<I>) -> Self {
+        let node_ptr = {
+            let arc_node = Arc::new(node);
+            Arc::into_raw(arc_node) as usize
+        };
+        unsafe { Self::new(node_ptr, EntryType::Node) }
     }
 
     pub fn is_node(&self) -> bool {
-        self.is_internal() && self.raw > (SLOT_SIZE << 2)
+        self.ty() == Some(EntryType::Node)
     }
 
-    pub fn from_item(item: I) -> Self {
-        let raw = I::into_raw(item);
-        unsafe { Self::new(raw as usize) }
+    pub fn as_node_ref(&self) -> Option<&XNode<I>> {
+        if !self.is_node() {
+            return None;
+        }
+
+        Some(unsafe { &*(self.ptr() as *const XNode<I>) })
     }
 
-    pub fn into_item(self) -> Option<I> {
-        if self.is_item() {
-            let item = unsafe { I::from_raw(self.raw) };
-            core::mem::forget(self);
-            Some(item)
-        } else {
-            None
+    pub fn as_node_maybe_mut(&mut self) -> Option<NodeMaybeMut<'_, I>> {
+        match self.node_strong_count() {
+            0 => None,
+            1 => Some(NodeMaybeMut::Exclusive(unsafe {
+                &mut *(self.ptr() as *mut _)
+            })),
+            _ => Some(NodeMaybeMut::Shared(unsafe { &*(self.ptr() as *const _) })),
         }
     }
 
-    pub fn as_item_ref(&'a self) -> Option<ItemRef<'a, I>> {
-        if self.is_item() {
-            let item_entry = unsafe { ManuallyDrop::new(I::from_raw(self.raw)) };
-            Some(ItemRef {
-                item: item_entry,
-                _marker: PhantomData,
-            })
-        } else {
-            None
+    pub fn as_node_mut_or_cow(&mut self) -> Option<&mut XNode<I>> {
+        match self.node_strong_count() {
+            0 => return None,
+            1 => return Some(unsafe { &mut *(self.ptr() as *mut _) }),
+            _ => (),
         }
+
+        let node = unsafe { &*(self.ptr() as *const XNode<I>) };
+        let new_node = node.try_clone().unwrap();
+
+        *self = Self::from_node(new_node);
+        Some(unsafe { &mut *(self.ptr() as *mut XNode<I>) })
     }
 
-    pub fn from_node<Operation>(node: XNode<I, L, Operation>) -> Self {
-        let node_ptr = {
-            let arc_node = Arc::new(node);
-            Arc::into_raw(arc_node)
-        };
-        unsafe { Self::new(node_ptr as usize | 2) }
+    fn node_strong_count(&self) -> usize {
+        if !self.is_node() {
+            return 0;
+        }
+
+        let node = unsafe { ManuallyDrop::new(Arc::from_raw(self.ptr() as *const XNode<I>)) };
+        Arc::strong_count(&*node)
+    }
+}
+
+impl<I: ItemEntry> XEntry<I> {
+    pub fn from_item(item: I) -> Self {
+        let item_ptr = I::into_raw(item) as usize;
+        unsafe { Self::new(item_ptr, EntryType::Item) }
     }
 
-    pub fn as_node(&self) -> Option<&XNode<I, L>> {
-        if self.is_node() {
-            unsafe {
-                let node_ref = &*((self.raw - 2) as *const XNode<I, L>);
-                Some(node_ref)
-            }
-        } else {
-            None
+    pub fn is_item(&self) -> bool {
+        self.ty() == Some(EntryType::Item)
+    }
+
+    pub fn into_item(self) -> Option<I> {
+        if !self.is_item() {
+            return None;
         }
+
+        let ptr = self.ptr();
+        core::mem::forget(self);
+
+        Some(unsafe { I::from_raw(ptr) })
     }
 
-    pub fn as_node_mut(&self) -> Option<&XNode<I, L, ReadWrite>> {
-        if self.is_node() {
-            unsafe {
-                let node_ref = &*((self.raw - 2) as *const XNode<I, L, ReadWrite>);
-                Some(node_ref)
-            }
-        } else {
-            None
+    pub fn as_item_ref(&self) -> Option<ItemRef<'_, I>> {
+        if !self.is_item() {
+            return None;
         }
+
+        let ptr = self.ptr();
+
+        Some(ItemRef {
+            item: unsafe { ManuallyDrop::new(I::from_raw(ptr)) },
+            _marker: PhantomData,
+        })
     }
+}
 
-    pub fn node_strong_count(&self) -> Option<usize> {
-        if self.is_node() {
-            let raw_ptr = (self.raw - 2) as *const u8;
-            let arc = unsafe { Arc::from_raw(raw_ptr) };
-            let strong_count = Arc::strong_count(&arc);
-            core::mem::forget(arc);
-            Some(strong_count)
-        } else {
-            None
+impl<I: ItemEntry> Drop for XEntry<I> {
+    fn drop(&mut self) {
+        match self.ty() {
+            None => (),
+            Some(EntryType::Item) => unsafe {
+                I::from_raw(self.ptr());
+            },
+            Some(EntryType::Node) => unsafe {
+                Arc::from_raw(self.ptr() as *const XNode<I>);
+            },
+        }
+    }
+}
+
+impl<I: ItemEntry + Clone> Clone for XEntry<I> {
+    fn clone(&self) -> Self {
+        match self.ty() {
+            None => Self::EMPTY,
+            Some(EntryType::Item) => unsafe {
+                let item_entry = ManuallyDrop::new(I::from_raw(self.ptr()));
+                Self::from_item((*item_entry).clone())
+            },
+            Some(EntryType::Node) => unsafe {
+                Arc::increment_strong_count(self.ptr() as *const XNode<I>);
+                Self {
+                    raw: self.raw,
+                    _marker: PhantomData,
+                }
+            },
         }
     }
 }

src/lib.rs

@@ -10,18 +10,13 @@ extern crate alloc;
 
 pub use cursor::{Cursor, CursorMut};
 pub use entry::ItemEntry;
-pub use lock::{MutexLock, XLock};
 pub use mark::XMark;
 pub use range::Range;
 pub use xarray::XArray;
 
-#[cfg(feature = "std")]
-pub use lock::std_specific::*;
-
-mod cow;
+mod borrow;
 mod cursor;
 mod entry;
-mod lock;
 mod mark;
 mod node;
 mod range;

src/lock.rs

@@ -1,70 +0,0 @@
-use core::ops::{Deref, DerefMut};
-
-/// MutexLock is a trait that needs to be implemented for locks used internally within XArray.
-/// It abstracts the functionalities of the necessary locks inside.
-///
-/// Since XArray features a copy-on-write cloning capability, its internal nodes may be subject
-/// to concurrent access in a multi-threaded environment. Therefore,
-/// the mutable data within XNode needs to be managed using a mutual exclusion lock.
-pub trait MutexLock<T>: Sized {
-    type Target<'a>: Deref<Target = T> + DerefMut<Target = T>
-    where
-        Self: 'a;
-
-    fn new(inner: T) -> Self;
-
-    fn lock(&self) -> Self::Target<'_>;
-}
-
-/// XLock represents a HKT (Higher-Kind Type) abstraction of MutexLock used within XArray,
-/// leveraging Rust's GAT (Generic Associated Types) to empower an HKT.
-///
-/// This trait is typically auto-implemented via the abstract_lock_to! macro. For example, for a lock type Mutex<T>,
-/// using `abstract_lock_to!(Mutex, XMutex);` yields the corresponding higher-kind type XMutex,
-/// which is automatically implemented with the XLock trait inside the macro. This allows XMutex to serve any type T,
-/// obtaining the corresponding Mutex<T> by using `XMutex::Lock<T>`.
-pub trait XLock {
-    type Lock<T>: MutexLock<T>;
-
-    fn new<T>(inner: T) -> Self::Lock<T> {
-        Self::Lock::<T>::new(inner)
-    }
-}
-
-/// Abstract a lock type that implements `MutexLock` to its HKT (Higher-Kinded Type) struct.
-/// The first parameter is the source type name and the second parameter is the HKT type name.
-/// This HKT type will implement `XLock` trait automatically and can be used as a generic parameter
-/// for `XArray`.
-#[macro_export]
-macro_rules! abstract_lock_to {
-    ($lock_type:ident, $name:ident) => {
-        pub struct $name;
-
-        impl XLock for $name {
-            type Lock<T> = $lock_type<T>;
-        }
-    };
-}
-
-#[cfg(feature = "std")]
-pub mod std_specific {
-    extern crate std;
-
-    use crate::*;
-    use std::sync::{Mutex, MutexGuard};
-
-    impl<T> MutexLock<T> for Mutex<T> {
-        type Target<'a> = MutexGuard<'a, T>
-        where T: 'a;
-
-        fn new(inner: T) -> Self {
-            Mutex::new(inner)
-        }
-
-        fn lock(&self) -> Self::Target<'_> {
-            self.lock().unwrap()
-        }
-    }
-
-    abstract_lock_to!(Mutex, StdMutex);
-}

src/mark.rs

@@ -21,6 +21,20 @@ impl Mark {
         self.inner &= !(1 << offset as u64);
     }
 
+    pub fn update(&mut self, offset: u8, set: bool) -> bool {
+        let mut new_inner = self.inner;
+        if set {
+            new_inner |= 1 << offset as u64;
+        } else {
+            new_inner &= !(1 << offset as u64);
+        }
+
+        let changed = new_inner != self.inner;
+        self.inner = new_inner;
+
+        changed
+    }
+
     pub fn clear(&mut self) {
         self.inner = 0
     }
@@ -44,6 +58,8 @@ pub enum XMark {
     Mark2,
 }
 
+pub const NUM_MARKS: usize = 3;
+
 impl XMark {
     /// Map the XMark to an index in the range 0 to 2.
     pub(super) fn index(&self) -> usize {

src/node.rs

@@ -1,18 +1,10 @@
 use core::cmp::Ordering;
-use core::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-};
+use core::ops::{Deref, DerefMut};
 
-use crate::cow::Cow;
 use crate::entry::{ItemEntry, XEntry};
-use crate::lock::{MutexLock, XLock};
-use crate::mark::Mark;
+use crate::mark::{Mark, NUM_MARKS};
 use crate::xarray::{BITS_PER_LAYER, SLOT_MASK, SLOT_SIZE};
 
-pub(super) struct ReadOnly {}
-pub(super) struct ReadWrite {}
-
 /// The height of an XNode within an XArray.
 ///
 /// In an XArray, the head has the highest height, while the XNodes that directly store items are at the lowest height,
@@ -54,6 +46,22 @@ impl Height {
         Self { height }
     }
 
+    pub fn from_index(index: u64) -> Self {
+        let mut height = Height::new(1);
+        while index > height.max_index() {
+            *height += 1;
+        }
+        height
+    }
+
+    pub fn go_root(&self) -> Self {
+        Self::new(self.height + 1)
+    }
+
+    pub fn go_leaf(&self) -> Self {
+        Self::new(self.height - 1)
+    }
+
     fn height_shift(&self) -> u8 {
         (self.height - 1) * BITS_PER_LAYER as u8
     }
@@ -77,10 +85,10 @@ impl Height {
 /// XNode has a generic parameter called 'Operation', which has two possible instances: `ReadOnly` and `ReadWrite`.
 /// These instances indicate whether the XNode will only perform read operations or both read and write operations
 /// (where write operations imply potential modifications to the contents of slots).
-pub(super) struct XNode<I, L, Operation = ReadOnly>
+#[derive(Clone, Debug)]
+pub(super) struct XNode<I>
 where
     I: ItemEntry,
-    L: XLock,
 {
     /// The height of the subtree rooted at the current node. The height of a leaf node,
     /// which stores the user-given items, is 1.
@@ -88,26 +96,21 @@ where
     /// This node is its parent's `offset_in_parent`-th child.
     /// This field is meaningless if this node is the root (will be 0).
     offset_in_parent: u8,
-    inner: L::Lock<XNodeInner<I, L>>,
-    _marker: PhantomData<Operation>,
+    slots: [XEntry<I>; SLOT_SIZE],
+    marks: [Mark; NUM_MARKS],
 }
 
-struct XNodeInner<I, L>
-where
-    I: ItemEntry,
-    L: XLock,
-{
-    slots: [XEntry<I, L>; SLOT_SIZE],
-    marks: [Mark; 3],
-}
+impl<I: ItemEntry> XNode<I> {
+    pub fn new_root(height: Height) -> Self {
+        Self::new(height, 0)
+    }
 
-impl<I: ItemEntry, L: XLock, Operation> XNode<I, L, Operation> {
     pub fn new(height: Height, offset: u8) -> Self {
         Self {
             height,
             offset_in_parent: offset,
-            inner: L::new(XNodeInner::new()),
-            _marker: PhantomData,
+            slots: [XEntry::EMPTY; SLOT_SIZE],
+            marks: [Mark::EMPTY; NUM_MARKS],
         }
     }
 
@@ -124,132 +127,90 @@ impl<I: ItemEntry, L: XLock, Operation> XNode<I, L, Operation> {
         self.offset_in_parent
     }
 
-    pub fn is_marked(&self, offset: u8, mark: usize) -> bool {
-        self.inner.lock().is_marked(offset, mark)
+    pub fn entry(&self, offset: u8) -> &XEntry<I> {
+        &self.slots[offset as usize]
     }
 
-    pub fn is_mark_clear(&self, mark: usize) -> bool {
-        self.inner.lock().is_mark_clear(mark)
+    pub fn entry_mut(&mut self, offset: u8) -> &mut XEntry<I> {
+        &mut self.slots[offset as usize]
     }
 
-    pub fn mark(&self, mark: usize) -> Mark {
-        self.inner.lock().marks[mark]
+    pub fn entries_mut(&mut self) -> &mut [XEntry<I>] {
+        &mut self.slots
     }
 
-    pub fn is_leaf(&self) -> bool {
-        self.height == 1
-    }
-}
-
-impl<I: ItemEntry, L: XLock> XNode<I, L, ReadOnly> {
-    /// Obtain a reference to the XEntry in the slots of the node. The input `offset` indicate
-    /// the offset of the target XEntry in the slots.
-    ///
-    /// # Safety
-    /// Users should ensure that no modifications for slots are made to the current XNode
-    /// while the reference to the returned XEntry exists.
-    pub unsafe fn ref_node_entry(&self, offset: u8) -> &XEntry<I, L> {
-        let lock = self.inner.lock();
-
-        let entry_ptr = &lock.slots[offset as usize] as *const XEntry<I, L>;
-        unsafe { &*entry_ptr }
+    pub fn is_marked(&self, offset: u8, mark: usize) -> bool {
+        self.marks[mark].is_marked(offset)
     }
-}
 
-impl<I: ItemEntry, L: XLock> XNode<I, L, ReadWrite> {
-    /// Obtain a reference to the XEntry in the slots of the node. The input `offset` indicate
-    /// the offset of target XEntry in the slots.
-    ///
-    /// # Safety
-    /// Users should ensure that no modifications for slots are made to the current XNode
-    /// while the reference to the returned XEntry exists.
-    pub unsafe fn ref_node_entry(&self, is_exclusive: bool, offset: u8) -> &XEntry<I, L> {
-        let mut lock = self.inner.lock();
-
-        // When a modification to the target entry is needed, it first checks whether the entry is shared with other XArrays.
-        // If it is, then it performs COW by allocating a new entry and using it,
-        // to prevent the modification from affecting the read or write operations on other XArrays.
-        if is_exclusive {
-            if let Some(new_entry) = lock.slots[offset as usize].copy_if_shared() {
-                lock.set_entry(offset, new_entry);
-            }
-        }
-        let entry_ptr = &lock.slots[offset as usize] as *const XEntry<I, L>;
-        unsafe { &*entry_ptr }
+    pub fn is_mark_clear(&self, mark: usize) -> bool {
+        self.marks[mark].is_clear()
     }
 
-    pub fn set_entry(&self, offset: u8, entry: XEntry<I, L>) -> XEntry<I, L> {
-        self.inner.lock().set_entry(offset, entry)
+    pub fn mark(&self, mark: usize) -> Mark {
+        self.marks[mark]
     }
 
-    pub fn set_mark(&self, offset: u8, mark: usize) {
-        self.inner.lock().set_mark(offset, mark)
+    pub fn is_leaf(&self) -> bool {
+        self.height == 1
     }
 
-    pub fn unset_mark(&self, offset: u8, mark: usize) {
-        self.inner.lock().unset_mark(offset, mark)
-    }
+    pub fn set_entry(&mut self, offset: u8, entry: XEntry<I>) -> XEntry<I> {
+        let is_new_node = entry.is_node();
 
-    pub fn clear_mark(&self, mark: usize) {
-        self.inner.lock().clear_mark(mark)
-    }
-}
+        let old_entry = core::mem::replace(&mut self.slots[offset as usize], entry);
 
-impl<I: ItemEntry, L: XLock> XNodeInner<I, L> {
-    fn new() -> Self {
-        Self {
-            slots: [XEntry::EMPTY; SLOT_SIZE],
-            marks: [Mark::EMPTY; 3],
+        if is_new_node {
+            self.update_mark(offset);
+            return old_entry;
         }
-    }
 
-    fn set_entry(&mut self, offset: u8, entry: XEntry<I, L>) -> XEntry<I, L> {
-        for i in 0..3 {
+        for i in 0..NUM_MARKS {
             self.marks[i].unset(offset);
         }
-        let old_entry = core::mem::replace(&mut self.slots[offset as usize], entry);
         old_entry
     }
 
-    fn set_mark(&mut self, offset: u8, mark: usize) {
+    pub fn set_mark(&mut self, offset: u8, mark: usize) {
         self.marks[mark].set(offset);
     }
 
-    fn unset_mark(&mut self, offset: u8, mark: usize) {
+    pub fn unset_mark(&mut self, offset: u8, mark: usize) {
         self.marks[mark].unset(offset);
     }
 
-    fn is_marked(&self, offset: u8, mark: usize) -> bool {
-        self.marks[mark].is_marked(offset)
+    pub fn clear_mark(&mut self, mark: usize) {
+        self.marks[mark].clear();
     }
 
-    fn is_mark_clear(&self, mark: usize) -> bool {
-        self.marks[mark].is_clear()
+    pub fn update_mark(&mut self, offset: u8) -> bool {
+        let Some(node) = self.slots[offset as usize].as_node_ref() else {
+            return false;
+        };
+
+        let mut changed = false;
+        for i in 0..NUM_MARKS {
+            changed |= self.marks[i].update(offset, !node.is_mark_clear(i));
+        }
+        changed
     }
+}
 
-    fn clear_mark(&mut self, mark: usize) {
-        self.marks[mark].clear();
+pub(super) trait TryClone
+where
+    Self: Sized,
+{
+    fn try_clone(&self) -> Option<Self>;
+}
+
+impl<I: ItemEntry> TryClone for XNode<I> {
+    default fn try_clone(&self) -> Option<Self> {
+        None
     }
 }
 
-pub(super) fn deep_copy_node_entry<I: ItemEntry + Clone, L: XLock>(
-    entry: &XEntry<I, L>,
-) -> XEntry<I, L> {
-    debug_assert!(entry.is_node());
-    let new_node = {
-        let cloned_node: &XNode<I, L> = entry.as_node().unwrap();
-        let new_node =
-            XNode::<I, L, ReadWrite>::new(cloned_node.height(), cloned_node.offset_in_parent());
-        let mut new_node_lock = new_node.inner.lock();
-        let cloned_node_lock = cloned_node.inner.lock();
-        new_node_lock.marks = cloned_node_lock.marks;
-        for i in 0..SLOT_SIZE {
-            let entry = &cloned_node_lock.slots[i];
-            let new_entry = entry.clone();
-            new_node_lock.slots[i as usize] = new_entry;
-        }
-        drop(new_node_lock);
-        new_node
-    };
-    XEntry::from_node(new_node)
+impl<I: ItemEntry + Clone> TryClone for XNode<I> {
+    fn try_clone(&self) -> Option<Self> {
+        Some(self.clone())
+    }
 }

src/range.rs

@@ -1,28 +1,25 @@
 use crate::cursor::Cursor;
 use crate::entry::{ItemEntry, ItemRef};
-use crate::lock::XLock;
 use crate::mark::XMark;
 
 /// An iterator over a sub-range of entries in a XArray.
 /// This struct is created by the `range()` method on `XArray`.
-pub struct Range<'a, I, L, M>
+pub struct Range<'a, I, M>
 where
     I: ItemEntry,
-    L: XLock,
     M: Into<XMark>,
 {
-    cursor: Cursor<'a, I, L, M>,
-    start: u64,
+    cursor: Cursor<'a, I, M>,
     end: u64,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> Range<'a, I, L, M> {
-    pub(super) fn new(cursor: Cursor<'a, I, L, M>, start: u64, end: u64) -> Self {
-        Range { cursor, start, end }
+impl<'a, I: ItemEntry, M: Into<XMark>> Range<'a, I, M> {
+    pub(super) fn new(cursor: Cursor<'a, I, M>, end: u64) -> Self {
+        Range { cursor, end }
     }
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> core::iter::Iterator for Range<'a, I, L, M> {
+impl<'a, I: ItemEntry, M: Into<XMark>> core::iter::Iterator for Range<'a, I, M> {
     type Item = (u64, ItemRef<'a, I>);
 
     fn next(&mut self) -> Option<Self::Item> {

src/test.rs

@@ -5,17 +5,14 @@ use std::sync::Arc;
 extern crate test;
 use test::Bencher;
 
-fn init_continuous_with_arc<M: Into<XMark>>(
-    xarray: &mut XArray<Arc<i32>, StdMutex, M>,
-    item_num: i32,
-) {
+fn init_continuous_with_arc<M: Into<XMark>>(xarray: &mut XArray<Arc<i32>, M>, item_num: i32) {
     for i in 0..item_num {
         let value = Arc::new(i);
         xarray.store(i as u64, value);
     }
 }
 
-fn init_sparse_with_arc<M: Into<XMark>>(xarray: &mut XArray<Arc<i32>, StdMutex, M>, item_num: i32) {
+fn init_sparse_with_arc<M: Into<XMark>>(xarray: &mut XArray<Arc<i32>, M>, item_num: i32) {
     for i in 0..2 * item_num {
         if i % 2 == 0 {
             let value = Arc::new(i);
@@ -135,7 +132,7 @@ fn test_cursor_store_sparse() {
 
 #[test]
 fn test_set_mark() {
-    let mut xarray_arc: XArray<Arc<i32>, StdMutex, XMark> = XArray::new();
+    let mut xarray_arc: XArray<Arc<i32>, XMark> = XArray::new();
     init_continuous_with_arc(&mut xarray_arc, 10000);
 
     let mut cursor = xarray_arc.cursor_mut(1000);
@@ -164,7 +161,7 @@ fn test_set_mark() {
 
 #[test]
 fn test_unset_mark() {
-    let mut xarray_arc: XArray<Arc<i32>, StdMutex, XMark> = XArray::new();
+    let mut xarray_arc: XArray<Arc<i32>, XMark> = XArray::new();
     init_continuous_with_arc(&mut xarray_arc, 10000);
 
     let mut cursor = xarray_arc.cursor_mut(1000);
@@ -182,7 +179,7 @@ fn test_unset_mark() {
 
 #[test]
 fn test_mark_overflow() {
-    let mut xarray_arc: XArray<Arc<i32>, StdMutex, XMark> = XArray::new();
+    let mut xarray_arc: XArray<Arc<i32>, XMark> = XArray::new();
     init_continuous_with_arc(&mut xarray_arc, 10000);
 
     let mut cursor = xarray_arc.cursor_mut(20000);
@@ -192,7 +189,7 @@ fn test_mark_overflow() {
 
 #[test]
 fn test_unset_mark_all() {
-    let mut xarray_arc: XArray<Arc<i32>, StdMutex, XMark> = XArray::new();
+    let mut xarray_arc: XArray<Arc<i32>, XMark> = XArray::new();
     init_continuous_with_arc(&mut xarray_arc, 10000);
     xarray_arc.cursor_mut(2000).set_mark(XMark::Mark1);
     xarray_arc.cursor_mut(2000).set_mark(XMark::Mark2);
@@ -300,7 +297,7 @@ fn test_cow_after_cow() {
 
 #[test]
 fn test_cow_mark() {
-    let mut xarray_arc: XArray<Arc<i32>, StdMutex, XMark> = XArray::new();
+    let mut xarray_arc: XArray<Arc<i32>, XMark> = XArray::new();
     for i in 1..10000 {
         let value = Arc::new(i * 2);
         xarray_arc.store(i as u64, value);

src/xarray.rs

@@ -1,14 +1,11 @@
 use alloc::collections::VecDeque;
 use core::marker::PhantomData;
 
-use crate::cow::Cow;
 use crate::cursor::{Cursor, CursorMut};
 use crate::entry::{ItemEntry, ItemRef, XEntry};
-use crate::lock::XLock;
 use crate::mark::{NoneMark, XMark};
+use crate::node::{Height, XNode};
 use crate::range::Range;
-#[cfg(feature = "std")]
-use crate::StdMutex;
 
 pub(super) const BITS_PER_LAYER: usize = 6;
 pub(super) const SLOT_SIZE: usize = 1 << BITS_PER_LAYER;
@@ -63,22 +60,17 @@ pub(super) const MAX_HEIGHT: usize = 64 / BITS_PER_LAYER + 1;
 ///
 /// The concepts XArray are originally introduced by Linux, which keeps the data structure of
 /// Linux's radix tree [Linux Radix Trees](https://lwn.net/Articles/175432/).
-pub struct XArray<
-    I,
-    #[cfg(feature = "std")] L = StdMutex,
-    #[cfg(not(feature = "std"))] L,
-    M = NoneMark,
-> where
+pub struct XArray<I, M = NoneMark>
+where
     I: ItemEntry,
-    L: XLock,
     M: Into<XMark>,
 {
     marks: [bool; 3],
-    head: XEntry<I, L>,
-    _marker: PhantomData<(I, M)>,
+    head: XEntry<I>,
+    _marker: PhantomData<M>,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> XArray<I, L, M> {
+impl<I: ItemEntry, M: Into<XMark>> XArray<I, M> {
     /// Make a new, empty XArray.
     pub const fn new() -> Self {
         Self {
@@ -104,39 +96,49 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> XArray<I, L, M> {
     }
 
     /// Return a reference to the head entry, and later will not modify the XNode pointed to by the `head`.
-    pub(super) fn head(&self) -> &XEntry<I, L> {
+    pub(super) fn head(&self) -> &XEntry<I> {
         &self.head
     }
 
-    /// Ensure current head in the XArray is exclusive.
-    ///
-    /// If it is shared with other XArrays, it will perform COW by allocating a new head and using it
-    /// to prevent the modification from affecting the read or write operations on other XArrays.
-    pub(super) fn ensure_head_exclusive(&mut self) {
-        if let Some(new_head) = self.head.copy_if_shared() {
-            self.set_head(new_head);
-        }
+    pub(super) fn head_mut(&mut self) -> &mut XEntry<I> {
+        &mut self.head
     }
 
-    /// Calculate the max index that can stored in the XArray with current height.
-    pub(super) fn max_index(&self) -> u64 {
-        if let Some(node) = self.head.as_node() {
-            node.height().max_index()
-        } else {
-            0
+    pub(super) fn reserve(&mut self, index: u64) {
+        if self.head.is_null() {
+            let height = Height::from_index(index);
+            self.head = XEntry::from_node(XNode::new_root(height));
+            return;
+        }
+
+        loop {
+            let height = self.head.as_node_ref().unwrap().height();
+
+            if height.max_index() >= index {
+                return;
+            }
+
+            let old_entry = core::mem::replace(&mut self.head, XEntry::EMPTY);
+
+            let mut new_node = XNode::new_root(height.go_root());
+            new_node.set_entry(0, old_entry);
+
+            self.head = XEntry::from_node(new_node);
         }
     }
 
-    /// Set the head of the `XArray` with the new `XEntry`, and return the old `head`.
-    pub(super) fn set_head(&mut self, head: XEntry<I, L>) -> XEntry<I, L> {
-        let old_head = core::mem::replace(&mut self.head, head);
-        old_head
+    /// Calculate the max index that can stored in the XArray with current height.
+    pub(super) fn max_index(&self) -> u64 {
+        self.head()
+            .as_node_ref()
+            .map(|node| node.height().max_index())
+            .unwrap_or(0)
     }
 
     /// Attempts to load the item at the target index within the `XArray`.
     /// If the target item exists, return it with `Some`, Otherwise, return `None`.
-    pub fn load(&'a self, index: u64) -> Option<ItemRef<'a, I>> {
-        let cursor = self.cursor(index);
+    pub fn load(&self, index: u64) -> Option<ItemRef<'_, I>> {
+        let mut cursor = self.cursor(index);
         cursor.load()
     }
 
@@ -149,27 +151,24 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> XArray<I, L, M> {
 
     /// Unset the input `mark` for all of the items in the `XArray`.
     pub fn unset_mark_all(&mut self, mark: M) {
-        let mut handle_list = VecDeque::new();
-        self.ensure_head_exclusive();
-        if let Some(node) = self.head().as_node_mut() {
-            handle_list.push_back(node);
+        let mut pending_nodes = VecDeque::new();
+
+        if let Some(node) = self.head.as_node_mut_or_cow() {
+            pending_nodes.push_back(node);
         }
+
         let mark_index = mark.into().index();
-        while !handle_list.is_empty() {
-            let node = handle_list.pop_front().unwrap();
-            let mut offset = 0;
+
+        while let Some(node) = pending_nodes.pop_front() {
             let node_mark = node.mark(mark_index);
-            while (offset as usize) < SLOT_SIZE {
-                if node_mark.is_marked(offset) {
-                    // SAFETY: This function will not modify any slots of the XNode.
-                    let entry = unsafe { node.ref_node_entry(true, offset) };
-                    if let Some(node) = entry.as_node_mut() {
-                        handle_list.push_back(node);
-                    }
-                }
-                offset += 1;
-            }
             node.clear_mark(mark_index);
+
+            node.entries_mut()
+                .iter_mut()
+                .enumerate()
+                .filter(|(offset, _)| node_mark.is_marked(*offset as u8))
+                .filter_map(|(_, next_entry)| next_entry.as_node_mut_or_cow())
+                .for_each(|next_node| pending_nodes.push_back(next_node));
         }
     }
 
@@ -181,24 +180,24 @@ impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> XArray<I, L, M> {
     }
 
     /// Create an `Cursor` to perform read related operations on the `XArray`.
-    pub fn cursor(&self, index: u64) -> Cursor<'_, I, L, M> {
+    pub fn cursor(&self, index: u64) -> Cursor<'_, I, M> {
         Cursor::new(self, index)
     }
 
     /// Create an `CursorMut` to perform read and write operations on the `XArray`.
-    pub fn cursor_mut(&mut self, index: u64) -> CursorMut<'_, I, L, M> {
+    pub fn cursor_mut(&mut self, index: u64) -> CursorMut<'_, I, M> {
         CursorMut::new(self, index)
     }
 
     /// Create a `Range` which can be immutably iterated over the index corresponding to the `range`
     /// in `XArray`.
-    pub fn range(&self, range: core::ops::Range<u64>) -> Range<'_, I, L, M> {
+    pub fn range(&self, range: core::ops::Range<u64>) -> Range<'_, I, M> {
         let cursor = Cursor::new(self, range.start);
-        Range::new(cursor, range.start, range.end)
+        Range::new(cursor, range.end)
     }
 }
 
-impl<I: ItemEntry + Clone, L: XLock, M: Into<XMark>> Clone for XArray<I, L, M> {
+impl<I: ItemEntry + Clone, M: Into<XMark>> Clone for XArray<I, M> {
     /// Clone with COW mechanism.
     fn clone(&self) -> Self {
         let cloned_head = self.head.clone();