Add next() functionality and refine internal designs.

src/cow.rs

@@ -1,4 +1,4 @@
-use crate::*;
+use super::*;
 
 /// The COW trait provides the capability for Copy-On-Write (COW) behavior to structures related to XArray,
 /// allowing them to perform COW operations on their internal XEntries.
@@ -9,13 +9,13 @@ pub(crate) trait Cow<I: ItemEntry> {
     fn copy_if_shared(&self, entry: &XEntry<I>) -> Option<XEntry<I>>;
 }
 
-impl<I: ItemEntry> Cow<I> for XNodeInner<I> {
+impl<I: ItemEntry> Cow<I> for XNode<I, ReadWrite> {
     default fn copy_if_shared(&self, _entry: &XEntry<I>) -> Option<XEntry<I>> {
         None
     }
 }
 
-impl<I: ItemEntry + Clone> Cow<I> for XNodeInner<I> {
+impl<I: ItemEntry + Clone> Cow<I> for XNode<I, ReadWrite> {
     fn copy_if_shared(&self, entry: &XEntry<I>) -> Option<XEntry<I>> {
         copy_if_shared(entry)
     }

src/cursor.rs

@@ -1,10 +1,9 @@
-use crate::*;
+use super::*;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
 
 /// CursorState represents the current state of the cursor. Currently, there are two possible states:
-/// 1. inactive: the initial state where the cursor is not positioned on any node.
+/// 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, Operation>
@@ -57,21 +56,24 @@ impl<'a, I: ItemEntry, Operation> CursorState<'a, I, Operation> {
     }
 }
 
-/// A `Cursor` can traverse in the `XArray` and have a target operated `XEntry`, which is stored in the `index` of `XArray`.
+/// A `Cursor` can traverse in the `XArray` and have a target `XEntry` to operate, which is stored in the `index` of `XArray`.
 /// `Cursor` can be only created by an `XArray`, and will hold its immutable reference, and can only perform read-only operations
 /// for the corresponding `XArray`.
-/// When a cursor traverses an XArray, at any given moment, it is positioned on an XNode. If not, it means that
-/// the cursor has not begin to traverse.
 ///
-/// After traversing, the `Cursor` will arrive at a node where the target entry can be operated on. If the arrival fails,
-/// it will be reset to its initial state, meaning it is not positioned at any node. Therefore, if the `Cursor` is not
-/// in the midst of a traversal operation, it is either not yet started or it has already reached a node where the
-/// target entry can be acted upon.
+/// When creating a cursor, it will immediately traverses to touch the target XEntry in the XArray. If the cursor cannot reach to the node
+/// that can operate the target XEntry, its state will set to `Inactive`. A Cursor can reset its target index.
+/// Once it do this, it will also immediately traverses to touch the target XEntry.  A Cursor can also perform `next()` to quickly operate the
+/// XEntry at the next index. If the Cursor perform reset or next and then have a target index that is not able to touch,
+/// the Cursor's state will also set to `Inactive`.
 ///
-/// Multiple Cursors are allowed to operate on a single XArray at the same time.
+/// Hence, at any given moment a cursor will be positioned on the XNode and be ready to operate its target XEntry.
+/// If not, it means that the cursor is not able to touch the target `XEntry`.
+///
+/// The cursor will also record all nodes passed from the head node to the target position in `passed_node`,
+/// thereby assisting it in performing some operations that involve searching upwards.
 ///
-/// TODO: Implement `next()` to allow to change the target index in cursors.
-pub(crate) struct Cursor<'a, I, M>
+/// Multiple Cursors are allowed to operate on a single XArray at the same time.
+pub struct Cursor<'a, I, M>
 where
     I: ItemEntry,
     M: ValidMark,
@@ -82,6 +84,9 @@ where
     index: u64,
     /// Represents the current state of the cursor.
     state: CursorState<'a, I, ReadOnly>,
+    /// Record add nodes passed from the head node to the target position.
+    /// The index is the layer of the recorded node.
+    passed_node: [Option<&'a XNode<I, ReadOnly>>; MAX_LAYER],
 
     _marker: PhantomData<I>,
 }
@@ -89,53 +94,80 @@ where
 impl<'a, I: ItemEntry, M: ValidMark> Cursor<'a, I, M> {
     /// Create an `Cursor` to perform read related operations on the `XArray`.
     pub(crate) fn new(xa: &'a XArray<I, M>, index: u64) -> Self {
-        Self {
+        let mut cursor = Self {
             xa,
             index,
             state: CursorState::default(),
+            passed_node: [None; MAX_LAYER],
             _marker: PhantomData,
-        }
-    }
-
-    /// Obtain a reference to the XEntry from a pointer pointing to it.
-    ///
-    /// # Safety
-    /// The user must ensure that the pointer remains valid for the duration of use of the target XEntry reference.
-    unsafe fn ref_entry(&self, entry_ptr: *const XEntry<I>) -> &'a XEntry<I> {
-        self.xa.ref_entry(entry_ptr)
-    }
+        };
 
-    /// Obtain a reference to the XEntry in the slots of target node. The input `offset` indicate
-    /// the offset of the XEntry in the slots.
-    fn ref_node_entry(&self, node: &'a XNode<I, ReadOnly>, offset: u8) -> &'a XEntry<I> {
-        let target_entry_ptr = node.entry(offset);
-        // Safety: The returned entry has the same lifetime with the XNode that owns it.
-        // Hence the position that `target_entry_ptr` points to will be valid during the usage of returned reference.
-        unsafe { self.ref_entry(target_entry_ptr) }
+        cursor.traverse_to_target();
+        cursor
     }
 
-    /// Move the `Cursor` to the `XNode` that `node_entry` points to, and update the cursor's state based on its target index.
+    /// 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, ReadOnly>) -> Option<&'a XEntry<I>> {
+    fn move_to(&mut self, node: &'a XNode<I, ReadOnly>) -> &'a XEntry<I> {
         let (current_entry, offset) = {
             let offset = node.entry_offset(self.index);
-            let current_entry = self.ref_node_entry(node, offset);
+            let current_entry = node.ref_node_entry(offset);
             (current_entry, offset)
         };
         self.state.arrive_node(node, offset);
-        Some(current_entry)
+        current_entry
+    }
+
+    /// 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.index = index;
+        self.traverse_to_target();
+    }
+
+    /// 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;
+        }
+
+        if self.xa.max_index() < self.index {
+            self.init();
+            return;
+        }
+
+        let (mut current_node, mut operation_offset) = self.state.node_info().unwrap();
+        operation_offset += 1;
+        while operation_offset == SLOT_SIZE as u8 {
+            operation_offset = current_node.offset_in_parent() + 1;
+            let parent_layer = (*current_node.layer() + 1) as usize;
+            self.passed_node[parent_layer - 1] = None;
+            current_node = self.passed_node[parent_layer].unwrap();
+        }
+        self.state.arrive_node(current_node, operation_offset);
+
+        while current_node.layer() != 0 {
+            let next_entry = current_node.ref_node_entry(operation_offset);
+            if !next_entry.is_node() {
+                self.init();
+                return;
+            }
+            let next_node = next_entry.as_node().unwrap();
+            self.passed_node[*next_node.layer() as usize] = Some(next_node);
+            self.move_to(next_node);
+            (current_node, operation_offset) = self.state.node_info().unwrap();
+        }
     }
 
     /// Judge if the target item is marked with the input `mark`.
     /// If target item does not exist, the function will return `None`.
-    pub(crate) fn is_marked(&mut self, mark: M) -> Option<bool> {
-        self.traverse_to_target();
-        if let CursorState::AtNode {
-            operation_offset,
-            node,
-        } = self.state
-        {
-            Some(node.is_marked(operation_offset, mark.index()))
+    pub fn is_marked(&mut self, mark: M) -> Option<bool> {
+        if let Some((current_node, operation_offset)) = self.state.node_info() {
+            Some(current_node.is_marked(operation_offset, mark.index()))
         } else {
             None
         }
@@ -145,18 +177,24 @@ impl<'a, I: ItemEntry, M: ValidMark> Cursor<'a, I, M> {
     ///
     /// 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(crate) fn load(&mut self) -> Option<&'a XEntry<I>> {
-        self.traverse_to_target()
+    pub fn load(&mut self) -> Option<&'a I> {
+        if let Some((current_node, operation_offset)) = self.state.node_info() {
+            let entry = current_node.ref_node_entry(operation_offset);
+            if entry.is_item() {
+                return Some(unsafe { &*(entry as *const XEntry<I> as *const I) });
+            }
+        }
+        None
     }
 
-    /// Traverse the subtree and move to the node that can operate the target entry.
+    /// 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>> {
         if self.is_arrived() {
             let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return Some(self.ref_node_entry(current_node, operation_offset));
+            return Some(current_node.ref_node_entry(operation_offset));
         }
 
         let max_index = self.xa.max_index();
@@ -165,54 +203,66 @@ impl<'a, I: ItemEntry, M: ValidMark> Cursor<'a, I, M> {
         }
         self.move_to(self.xa.head().as_node().unwrap());
 
-        let (current_node, operation_offset) = self.state.node_info().unwrap();
+        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
         let mut current_layer = current_node.layer();
-        let mut operated_entry = self.ref_node_entry(current_node, operation_offset);
+        let mut operated_entry = current_node.ref_node_entry(operation_offset);
         while current_layer > 0 {
-            if let None = operated_entry.as_node() {
+            if !operated_entry.is_node() {
                 self.init();
                 return None;
             }
 
+            self.passed_node[*current_layer as usize] = Some(current_node);
+
+            current_node = operated_entry.as_node().unwrap();
             *current_layer -= 1;
-            operated_entry = self.move_to(operated_entry.as_node().unwrap()).unwrap();
+            operated_entry = self.move_to(current_node);
         }
         Some(operated_entry)
     }
 
     /// Initialize the Cursor to its initial state.
-    fn init(&mut self) {
+    pub fn init(&mut self) {
         self.state = CursorState::default();
+        self.passed_node = [None; MAX_LAYER];
     }
 
     /// Return the target index of the cursor.
-    fn index(&mut self) -> u64 {
+    pub fn index(&mut self) -> u64 {
         self.index
     }
 
     /// 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.
-    fn is_arrived(&mut self) -> bool {
+    pub fn is_arrived(&mut self) -> bool {
         self.state.is_at_node()
     }
 }
 
-/// A `CursorMut` can traverse in the `XArray` and have a target operated `XEntry`, which is stored in the `index` of `XArray`.
-/// `Cursor` can be only created by an `XArray`, and will hold its mutable reference, and can perform read and write operations
+/// A `CursorMut` can traverse in the `XArray` and have a target `XEntry` to operate, which is stored in the `index` of `XArray`.
+/// `CursorMut` can be only created by an `XArray`, and will hold its mutable reference, and can perform read and write operations
 /// for the corresponding `XArray`.
-/// When a cursor traverses an XArray, at any given moment, it is positioned on an XNode. If not, it means that
-/// the cursor has not begin to traverse.
 ///
-/// After traversing, the `CursorMut` will arrive at a node where the target entry can be operated on. If the arrival fails,
-/// it will be reset to its initial state, meaning it is not positioned at any node. Therefore, if the `CursorMut` is not
-/// in the midst of a traversal operation, it is either not yet started or it has already reached a node where the
-/// target entry can be acted upon.
+/// When creating a `CursorMut`, it will immediately traverses to touch the target XEntry in the XArray. If the `CursorMut` cannot reach to the node
+/// that can operate the target XEntry, its state will set to `Inactive`. A `CursorMut` can reset its target index.
+/// Once it do this, it will also immediately traverses to touch the target XEntry.  A `CursorMut` can also perform `next()` to quickly operate the
+/// XEntry at the next index. If the `CursorMut` perform reset or next and then have a target index that is not able to touch,
+/// the `CursorMut`'s state will also set to `Inactive`.
 ///
-/// When a CursorMut doing operation on XArray, it should not be affected by other CursorMuts or affect other Cursors.
+/// Hence, at any given moment a `CursorMut` will be positioned on the XNode and be ready to operate its target XEntry.
+/// If not, it means that the `CursorMut` is not able to touch the target `XEntry`. For this situation, the `CursorMut`
+/// can invoke `store` method which will expand the XArray to guarantee to reach the target position.
+///
+/// The `CursorMut` will also record all nodes passed from the head node to the target position in passed_node,
+/// thereby assisting it in performing some operations that involve searching upwards.
+///
+/// **Features for COW (Copy-On-Write).** The CursorMut guarantees that all nodes it traverses during the process are exclusively owned by the current XArray.
+/// If it finds that the node it is about to access is shared with another XArray due to a COW clone, it will trigger a COW to copy and create an exclusive node for access.
+/// Additionally, since it holds a mutable reference to the current XArray, it will not conflict with any other cursors on the XArray.
 ///
-/// TODO: Implement `next()` to allow to change the target index in cursors.
-pub(crate) struct CursorMut<'a, I, M>
+/// When a CursorMut doing operation on XArray, it should not be affected by other CursorMuts or affect other Cursors.
+pub struct CursorMut<'a, I, M>
 where
     I: ItemEntry,
     M: ValidMark,
@@ -223,6 +273,9 @@ where
     index: u64,
     /// Represents the current state of the cursor.
     state: CursorState<'a, I, ReadWrite>,
+    /// Record add nodes passed from the head node to the target position.
+    /// The index is the layer of the recorded node.
+    passed_node: [Option<&'a XNode<I, ReadWrite>>; MAX_LAYER],
 
     _marker: PhantomData<I>,
 }
@@ -230,33 +283,35 @@ where
 impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
     /// Create an `CursorMut` to perform read and write operations on the `XArray`.
     pub(crate) fn new(xa: &'a mut XArray<I, M>, index: u64) -> Self {
-        Self {
+        let mut cursor = Self {
             xa,
             index,
             state: CursorState::default(),
+            passed_node: [None; MAX_LAYER],
             _marker: PhantomData,
-        }
-    }
+        };
 
-    /// Obtain a reference to the XEntry in the slots of target node. The input `offset` indicate
-    /// the offset of the XEntry in the slots.
-    fn ref_node_entry(&self, node: &'a XNode<I, ReadWrite>, offset: u8) -> &'a XEntry<I> {
-        let target_entry_ptr = node.entry(offset);
-        // Safety: The returned entry has the same lifetime with the XNode that owns it.
-        // Hence the position that `target_entry_ptr` points to will be valid during the usage of returned reference.
-        unsafe { self.ref_entry(target_entry_ptr) }
+        cursor.traverse_to_target();
+        cursor
     }
 
-    /// Move the `CursorMut` to the `XNode` that `node_entry` points to, and update the cursor's state based on its target index.
+    /// 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, ReadWrite>) -> Option<&'a XEntry<I>> {
+    fn move_to(&mut self, node: &'a XNode<I, ReadWrite>) -> &'a XEntry<I> {
         let (current_entry, offset) = {
             let offset = node.entry_offset(self.index);
-            let current_entry = self.ref_node_entry(node, offset);
+            let current_entry = node.ref_node_entry(offset);
             (current_entry, offset)
         };
         self.state.arrive_node(node, offset);
-        Some(current_entry)
+        current_entry
+    }
+
+    /// 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.index = index;
+        self.traverse_to_target();
     }
 
     /// Stores the provided `XEntry` in the `XArray` at the position indicated by the current cursor index.
@@ -264,14 +319,53 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
     /// 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(crate) fn store(&mut self, entry: XEntry<I>) -> XEntry<I> {
-        let target_entry = self.traverse_to_target_mut();
-        if entry.raw() == target_entry.raw() {
-            return entry;
+    pub fn store(&mut self, item: I) -> Option<I> {
+        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, entry);
-        return old_entry;
+        let old_entry = current_node.set_entry(operation_offset, stored_entry);
+        XEntry::into_item(old_entry)
+    }
+
+    /// 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;
+        }
+
+        if self.xa.max_index() < self.index {
+            self.init();
+            return;
+        }
+
+        let (mut current_node, mut operation_offset) = self.state.node_info().unwrap();
+        operation_offset += 1;
+        while operation_offset == SLOT_SIZE as u8 {
+            operation_offset = current_node.offset_in_parent() + 1;
+            let parent_layer = (*current_node.layer() + 1) as usize;
+            self.passed_node[parent_layer - 1] = None;
+            current_node = self.passed_node[parent_layer].unwrap();
+        }
+        self.state.arrive_node(current_node, operation_offset);
+
+        while current_node.layer() != 0 {
+            let next_entry = current_node.ref_node_entry(operation_offset);
+            if !next_entry.is_node() {
+                self.init();
+                return;
+            }
+            let next_node = next_entry.as_node_mut().unwrap();
+            self.passed_node[*next_node.layer() as usize] = Some(next_node);
+            self.move_to(next_node);
+            (current_node, operation_offset) = self.state.node_info().unwrap();
+        }
     }
 
     /// Mark the item at the target index in the `XArray` with the input `mark`.
@@ -279,19 +373,26 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
     ///
     /// This operation will also mark all nodes along the path from the head node to the target node with the input `mark`,
     /// because a marked intermediate node should be equivalent to having a child node that is marked.
-    pub(crate) fn set_mark(&mut self, mark: M) -> Result<(), ()> {
-        self.traverse_to_target();
+    pub fn set_mark(&mut self, mark: M) -> Result<(), ()> {
         if let Some((current_node, operation_offset)) = self.state.node_info() {
+            let item_entry = current_node.ref_node_entry(operation_offset);
+            if item_entry.is_null() {
+                return Err(());
+            }
+
             current_node.set_mark(operation_offset, mark.index());
+
+            let head_layer = *(self.xa.head().as_node().unwrap().layer()) as usize;
             let mut offset_in_parent = current_node.offset_in_parent();
-            let mut parent = current_node.parent();
-            while let Some(parent_node) = parent {
+            let mut parent_layer = (*current_node.layer() + 1) as usize;
+            while parent_layer <= head_layer {
+                let parent_node = self.passed_node[parent_layer].unwrap();
                 if parent_node.is_marked(offset_in_parent, mark.index()) {
                     break;
                 }
                 parent_node.set_mark(offset_in_parent, mark.index());
                 offset_in_parent = parent_node.offset_in_parent();
-                parent = parent_node.parent();
+                parent_layer += 1;
             }
             Ok(())
         } else {
@@ -304,17 +405,25 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, 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(crate) fn unset_mark(&mut self, mark: M) -> Result<(), ()> {
-        self.traverse_to_target();
+    pub fn unset_mark(&mut self, mark: M) -> Result<(), ()> {
         if let Some((mut current_node, operation_offset)) = self.state.node_info() {
+            let item_entry = current_node.ref_node_entry(operation_offset);
+            if item_entry.is_null() {
+                return Err(());
+            }
+
             current_node.unset_mark(operation_offset, mark.index());
+
+            let head_layer = *(self.xa.head().as_node().unwrap().layer()) as usize;
+            let mut parent_layer = (*current_node.layer() + 1) as usize;
             while current_node.is_mark_clear(mark.index()) {
                 let offset_in_parent = current_node.offset_in_parent();
-                let parent = current_node.parent();
-                if let Some(parent_node) = parent {
-                    parent_node.unset_mark(offset_in_parent, mark.index());
-                    current_node = parent_node;
-                } else {
+                let parent_node = self.passed_node[parent_layer].unwrap();
+                parent_node.unset_mark(offset_in_parent, mark.index());
+
+                current_node = parent_node;
+                parent_layer += 1;
+                if parent_layer > head_layer {
                     break;
                 }
             }
@@ -328,18 +437,22 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
     ///
     /// 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(crate) fn remove(&mut self) -> XEntry<I> {
-        self.store(XEntry::EMPTY)
+    pub fn remove(&mut self) -> Option<I> {
+        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
     }
 
-    /// Traverse the subtree and move to the node that can operate the target entry.
+    /// 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>> {
         if self.is_arrived() {
             let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return Some(self.ref_node_entry(current_node, operation_offset));
+            return Some(current_node.ref_node_entry(operation_offset));
         }
 
         let max_index = self.xa.max_index();
@@ -349,22 +462,25 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
         let head = self.xa.head_mut().as_node_mut().unwrap();
         self.move_to(head);
 
-        let (current_node, operation_offset) = self.state.node_info().unwrap();
+        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
         let mut current_layer = current_node.layer();
-        let mut operated_entry = self.ref_node_entry(current_node, operation_offset);
+        let mut operated_entry = current_node.ref_node_entry(operation_offset);
         while current_layer > 0 {
-            if let None = operated_entry.as_node() {
+            if !operated_entry.is_node() {
                 self.init();
                 return None;
             }
 
+            self.passed_node[*current_layer as usize] = Some(current_node);
+
+            current_node = operated_entry.as_node_mut().unwrap();
             *current_layer -= 1;
-            operated_entry = self.move_to(operated_entry.as_node_mut().unwrap()).unwrap();
+            operated_entry = self.move_to(current_node);
         }
         Some(operated_entry)
     }
 
-    /// Traverse the subtree and move to the node that can operate the target entry.
+    /// Traverse the XArray and move to the node that can operate the target entry.
     /// During the traverse, the cursor may modify the XArray to let itself be able to reach the target node.
     ///
     /// Before traverse, the cursor will first expand the layer of `XArray` to make sure it have enough capacity.
@@ -372,35 +488,36 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, 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 traverse_to_target_mut(&mut self) -> &'a XEntry<I> {
+    fn expand_and_traverse_to_target(&mut self) -> &'a XEntry<I> {
         if self.is_arrived() {
             let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return self.ref_node_entry(current_node, operation_offset);
+            return current_node.ref_node_entry(operation_offset);
         }
 
         self.expand_layer();
         let head_ref = self.xa.head_mut().as_node_mut().unwrap();
         self.move_to(head_ref);
 
-        let (current_node, operation_offset) = self.state.node_info().unwrap();
+        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
         let mut current_layer = current_node.layer();
-        let mut operated_entry = self.ref_node_entry(current_node, operation_offset);
+        let mut operated_entry = current_node.ref_node_entry(operation_offset);
         while current_layer > 0 {
-            if let None = operated_entry.as_node() {
+            if !operated_entry.is_node() {
                 let new_entry = {
                     let (current_node, operation_offset) = self.state.node_info().unwrap();
-                    let new_owned_entry = self.alloc_node(
-                        Layer::new(*current_layer - 1),
-                        operation_offset,
-                        Some(current_node),
-                    );
+                    let new_owned_entry =
+                        self.alloc_node(Layer::new(*current_layer - 1), operation_offset);
                     let _ = current_node.set_entry(operation_offset, new_owned_entry);
-                    self.ref_node_entry(current_node, operation_offset)
+                    current_node.ref_node_entry(operation_offset)
                 };
                 operated_entry = new_entry;
             }
+
+            self.passed_node[*current_layer as usize] = Some(current_node);
+
+            current_node = operated_entry.as_node_mut().unwrap();
             *current_layer -= 1;
-            operated_entry = self.move_to(operated_entry.as_node_mut().unwrap()).unwrap();
+            operated_entry = self.move_to(current_node);
         }
         operated_entry
     }
@@ -416,7 +533,7 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
             while self.index > head_layer.max_index() {
                 *head_layer += 1;
             }
-            let head = self.alloc_node(head_layer, 0, None);
+            let head = self.alloc_node(head_layer, 0);
             self.xa.set_head(head);
             return head_layer;
         } else {
@@ -430,11 +547,15 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
                     return head_layer;
                 }
 
-                let new_node_entry = self.alloc_node(Layer::new(*head_layer + 1), 0, None);
+                let new_node_entry = self.alloc_node(Layer::new(*head_layer + 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_mut().as_node_mut().unwrap();
-                old_head.set_parent(new_head);
+                for i in 0..3 {
+                    if !old_head.mark(i).is_clear() {
+                        new_head.set_mark(0, i);
+                    }
+                }
                 let _empty = new_head.set_entry(0, old_head_entry);
             }
         }
@@ -442,19 +563,8 @@ impl<'a, I: ItemEntry, M: ValidMark> CursorMut<'a, I, M> {
 
     /// Allocate a new XNode with the specified layer and offset,
     /// then generate a node entry from it and return it to the caller.
-    fn alloc_node(
-        &mut self,
-        layer: Layer,
-        offset: u8,
-        parent: Option<&XNode<I, ReadWrite>>,
-    ) -> XEntry<I> {
-        let parent = parent.map(|p| {
-            let arc = unsafe { Arc::from_raw(p as *const XNode<I, ReadWrite>) };
-            let weak = Arc::downgrade(&arc);
-            core::mem::forget(arc);
-            weak
-        });
-        XEntry::from_node(XNode::<I, ReadWrite>::new(layer, offset, parent))
+    fn alloc_node(&mut self, layer: Layer, offset: u8) -> XEntry<I> {
+        XEntry::from_node(XNode::<I, ReadWrite>::new(layer, offset))
     }
 }
 

src/entry.rs

@@ -1,7 +1,7 @@
 use core::marker::PhantomData;
 use std::{mem::ManuallyDrop, sync::Arc};
 
-use crate::*;
+use super::*;
 
 /// 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.

src/node.rs

@@ -2,10 +2,10 @@ use core::cmp::Ordering;
 use std::{
     marker::PhantomData,
     ops::{Deref, DerefMut},
-    sync::{Arc, Mutex, Weak},
+    sync::Mutex,
 };
 
-use crate::*;
+use super::*;
 
 pub(crate) struct ReadOnly {}
 pub(crate) struct ReadWrite {}
@@ -86,17 +86,16 @@ pub(crate) struct XNode<I: ItemEntry, Operation = ReadOnly> {
 }
 
 pub(crate) struct XNodeInner<I: ItemEntry> {
-    parent: Option<Weak<XNode<I, ReadWrite>>>,
     slots: [XEntry<I>; SLOT_SIZE],
     marks: [Mark; 3],
 }
 
 impl<I: ItemEntry, Operation> XNode<I, Operation> {
-    pub(crate) fn new(layer: Layer, offset: u8, parent: Option<Weak<XNode<I, ReadWrite>>>) -> Self {
+    pub(crate) fn new(layer: Layer, offset: u8) -> Self {
         Self {
             layer,
             offset_in_parent: offset,
-            inner: Mutex::new(XNodeInner::new(parent)),
+            inner: Mutex::new(XNodeInner::new()),
             _marker: PhantomData,
         }
     }
@@ -128,46 +127,41 @@ impl<I: ItemEntry, Operation> XNode<I, Operation> {
 }
 
 impl<I: ItemEntry> XNode<I, ReadOnly> {
-    pub(crate) fn parent(&self) -> Option<&XNode<I, ReadOnly>> {
-        self.inner
-            .lock()
-            .unwrap()
-            .parent
-            .as_ref()
-            .map(|parent| unsafe { &*(parent.as_ptr() as *const XNode<I, ReadOnly>) })
+    fn entry<'a>(&'a self, offset: u8) -> *const XEntry<I> {
+        let lock = self.inner.lock().unwrap();
+        &lock.slots[offset as usize] as *const XEntry<I>
     }
 
-    pub(crate) fn entry<'a>(&'a self, offset: u8) -> *const XEntry<I> {
-        let lock = self.inner.lock().unwrap();
-        let entry = lock.entry(offset);
-        entry
+    /// 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.
+    pub(crate) fn ref_node_entry(&self, offset: u8) -> &XEntry<I> {
+        let target_entry_ptr = self.entry(offset);
+        // Safety: The returned entry has the same lifetime with the XNode that owns it.
+        // Hence the position that `target_entry_ptr` points to will be valid during the usage of returned reference.
+        unsafe { &*target_entry_ptr }
     }
 }
 
 impl<I: ItemEntry> XNode<I, ReadWrite> {
-    pub(crate) fn parent(&self) -> Option<&XNode<I, ReadWrite>> {
-        self.inner
-            .lock()
-            .unwrap()
-            .parent
-            .as_ref()
-            .map(|parent| unsafe { &*(parent.as_ptr()) })
-    }
-
-    pub(crate) fn entry<'a>(&'a self, offset: u8) -> *const XEntry<I> {
+    fn entry<'a>(&'a self, offset: u8) -> *const XEntry<I> {
         let mut lock = self.inner.lock().unwrap();
-        let entry = lock.entry_mut(offset);
-        entry
+
+        // 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 let Some(new_entry) = self.copy_if_shared(&lock.slots[offset as usize]) {
+            lock.set_entry(offset, new_entry);
+        }
+        &lock.slots[offset as usize] as *const XEntry<I>
     }
 
-    pub(crate) fn set_parent(&self, parent: &XNode<I, ReadWrite>) {
-        let parent = {
-            let arc = unsafe { Arc::from_raw(parent as *const XNode<I, ReadWrite>) };
-            let weak = Arc::downgrade(&arc);
-            core::mem::forget(arc);
-            weak
-        };
-        self.inner.lock().unwrap().parent = Some(parent);
+    /// Obtain a reference to the XEntry in the slots of the node. The input `offset` indicate
+    /// the offset of target XEntry in the slots.
+    pub(crate) fn ref_node_entry<'a>(&self, offset: u8) -> &XEntry<I> {
+        let target_entry_ptr = self.entry(offset);
+        // Safety: The returned entry has the same lifetime with the XNode that owns it.
+        // Hence the position that `target_entry_ptr` points to will be valid during the usage of returned reference.
+        unsafe { &*target_entry_ptr }
     }
 
     pub(crate) fn set_entry(&self, offset: u8, entry: XEntry<I>) -> XEntry<I> {
@@ -188,29 +182,17 @@ impl<I: ItemEntry> XNode<I, ReadWrite> {
 }
 
 impl<I: ItemEntry> XNodeInner<I> {
-    pub(crate) fn new(parent: Option<Weak<XNode<I, ReadWrite>>>) -> Self {
+    pub(crate) fn new() -> Self {
         Self {
-            parent,
             slots: [XEntry::EMPTY; SLOT_SIZE],
             marks: [Mark::EMPTY; 3],
         }
     }
 
-    pub(crate) fn entry(&self, offset: u8) -> *const XEntry<I> {
-        &self.slots[offset as usize] as *const XEntry<I>
-    }
-
-    pub(crate) fn entry_mut(&mut self, offset: u8) -> *const XEntry<I> {
-        // 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 let Some(new_entry) = self.copy_if_shared(&self.slots[offset as usize]) {
-            self.set_entry(offset, new_entry);
-        }
-        &self.slots[offset as usize] as *const XEntry<I>
-    }
-
     pub(crate) fn set_entry(&mut self, offset: u8, entry: XEntry<I>) -> XEntry<I> {
+        for i in 0..3 {
+            self.marks[i].unset(offset);
+        }
         let old_entry = core::mem::replace(&mut self.slots[offset as usize], entry);
         old_entry
     }
@@ -240,11 +222,8 @@ pub(crate) fn deep_clone_node_entry<I: ItemEntry + Clone>(entry: &XEntry<I>) ->
     debug_assert!(entry.is_node());
     let new_node = {
         let cloned_node: &XNode<I> = entry.as_node().unwrap();
-        let new_node = XNode::<I, ReadWrite>::new(
-            cloned_node.layer(),
-            cloned_node.offset_in_parent(),
-            cloned_node.inner.lock().unwrap().parent.clone(),
-        );
+        let new_node =
+            XNode::<I, ReadWrite>::new(cloned_node.layer(), cloned_node.offset_in_parent());
         let mut new_node_lock = new_node.inner.lock().unwrap();
         let cloned_node_lock = cloned_node.inner.lock().unwrap();
         new_node_lock.marks = cloned_node_lock.marks;

src/test.rs

@@ -54,9 +54,14 @@ fn test_mark() {
         let value = Arc::new(i * 2);
         xarray_arc.store(i as u64, value);
     }
-    xarray_arc.set_mark(1000, MarkDemo::Mark0).unwrap();
-    xarray_arc.set_mark(1000, MarkDemo::Mark1).unwrap();
-    xarray_arc.set_mark(2000, MarkDemo::Mark1).unwrap();
+    let mut cursor = xarray_arc.cursor_mut(1000);
+    cursor.set_mark(MarkDemo::Mark0).unwrap();
+    cursor.set_mark(MarkDemo::Mark1).unwrap();
+    cursor.reset_to(2000);
+    cursor.set_mark(MarkDemo::Mark1).unwrap();
+    cursor.reset_to(20000);
+    assert!(Err(()) == cursor.set_mark(MarkDemo::Mark1));
+    assert!(None == cursor.load());
     let (value1, value1_mark0) = xarray_arc.load_with_mark(1000, MarkDemo::Mark0).unwrap();
     let (_, value1_mark1) = xarray_arc.load_with_mark(1000, MarkDemo::Mark1).unwrap();
     let (value2, value2_mark1) = xarray_arc.load_with_mark(2000, MarkDemo::Mark1).unwrap();
@@ -70,15 +75,14 @@ fn test_mark() {
     assert!(value2_mark0 == false);
     assert!(value2_mark1 == true);
     assert!(value3_mark1 == false);
-    assert!(Err(()) == xarray_arc.set_mark(20000, MarkDemo::Mark1));
 
-    xarray_arc.unset_mark(1000, MarkDemo::Mark0).unwrap();
-    xarray_arc.unset_mark(1000, MarkDemo::Mark2).unwrap();
+    let mut cursor = xarray_arc.cursor_mut(1000);
+    cursor.unset_mark(MarkDemo::Mark0).unwrap();
+    cursor.unset_mark(MarkDemo::Mark2).unwrap();
     let (_, value1_mark0) = xarray_arc.load_with_mark(1000, MarkDemo::Mark0).unwrap();
     let (_, value1_mark2) = xarray_arc.load_with_mark(1000, MarkDemo::Mark2).unwrap();
     assert!(value1_mark0 == false);
     assert!(value1_mark2 == false);
-    assert!(Err(()) == xarray_arc.unset_mark(20000, MarkDemo::Mark1));
 
     xarray_arc.unset_mark_all(MarkDemo::Mark1);
     let (_, value2_mark1) = xarray_arc.load_with_mark(2000, MarkDemo::Mark1).unwrap();
@@ -164,10 +168,15 @@ fn test_cow_mark() {
         xarray_arc.store(i as u64, value);
     }
     let mut xarray_clone = xarray_arc.clone();
-    xarray_arc.set_mark(1000, MarkDemo::Mark0).unwrap();
-    xarray_arc.set_mark(2000, MarkDemo::Mark0).unwrap();
-    xarray_clone.set_mark(1000, MarkDemo::Mark1).unwrap();
-    xarray_arc.set_mark(3000, MarkDemo::Mark0).unwrap();
+    let mut cursor_arc = xarray_arc.cursor_mut(1000);
+    let mut cursor_clone = xarray_clone.cursor_mut(1000);
+    cursor_arc.set_mark(MarkDemo::Mark0).unwrap();
+    cursor_arc.reset_to(2000);
+    cursor_arc.set_mark(MarkDemo::Mark0).unwrap();
+    cursor_arc.reset_to(3000);
+    cursor_arc.set_mark(MarkDemo::Mark0).unwrap();
+
+    cursor_clone.set_mark(MarkDemo::Mark1).unwrap();
 
     let (_, mark0_1000_arc) = xarray_arc.load_with_mark(1000, MarkDemo::Mark0).unwrap();
     let (_, mark0_2000_arc) = xarray_arc.load_with_mark(2000, MarkDemo::Mark0).unwrap();
@@ -187,3 +196,27 @@ fn test_cow_mark() {
     assert!(mark0_3000_arc == true);
     assert!(mark0_3000_clone == false);
 }
+
+#[test]
+fn test_next() {
+    let mut xarray_arc: XArray<Arc<i32>> = XArray::new();
+    for i in 1..10000 {
+        let value = Arc::new(i * 2);
+        xarray_arc.store(i as u64, value);
+    }
+    let mut cursor = xarray_arc.cursor_mut(0);
+    for i in 1..10000 {
+        cursor.next();
+        let value = cursor.load().unwrap();
+        assert!(*value.as_ref() == i * 2)
+    }
+    for i in 0..10000 {
+        cursor.next();
+        let value = Arc::new((10000 + i) * 2);
+        cursor.store(value);
+    }
+    for i in 10000..20000 {
+        let value = xarray_arc.load(i as u64).unwrap();
+        assert!(*value.as_ref() == i * 2)
+    }
+}

src/xarray.rs

@@ -1,29 +1,31 @@
 use std::{collections::VecDeque, marker::PhantomData};
 
-use crate::*;
+use super::*;
 
 pub(crate) const BITS_PER_LAYER: usize = 6;
 pub(crate) const SLOT_SIZE: usize = 1 << BITS_PER_LAYER;
 pub(crate) const SLOT_MASK: usize = SLOT_SIZE - 1;
+pub(crate) const MAX_LAYER: usize = 64 / BITS_PER_LAYER + 1;
 
-/// The XArray is an abstract data type which behaves like a very large array of items.
-/// Items here must be a 8 bytes object, like `Arc<T>` and `Box<T>`.
-/// The alignment of the pointers stored by users must be at least 4.
-/// It allows you to sensibly go to the next or previous entry in a cache-efficient manner.
-/// It allows multiple concurrent reads of the XArray, but only permits one write operation on the XArray at any given time.
+/// `XArray` is an abstract data type functioning like an expansive array of items where each item must be an 8-byte object, such as `Arc<T>` or `Box<T>`.
+/// User-stored pointers must have a minimum alignment of 4 bytes. `XArray` facilitates efficient sequential access to adjacent entries,
+/// supporting multiple concurrent reads and exclusively allowing one write operation at a time.
 ///
 /// # Features
-/// **Copy-on-write (COW).** If the item stored in `XArray` implemented `Clone` trait, the `XArray`
-/// can achieve Clone with a COW mechanism. When cloning an XArray, initially the new XArray shares a head with the original XArray
-/// without performing an actual clone. If either of the XArrays needs to perform a mutable operation, a substantive clone of the XNode to be modified is created before making the update.
-/// This ensures that operations on the two XArrays do not affect each other.
-/// **Reference.** All operations on XArray are performed through `Cursor` and `CursorMut`.
-/// Cursor requires an immutable reference to XArray, while CursorMut requires a mutable reference.
-/// Therefore, XArray can have multiple Cursors operating at the same time, whereas the operations of CursorMut are exclusive (similar to the relationship between & and &mut).
-/// **Mark.** `XArray` supports the ability to add marks to any stored item to assist users.
-/// By default, an item can be marked with up to three different marks, with each mark being independent of the others.
-/// Marks for an item are typically enumerations that must implement the ValidMark trait.
-/// Internal nodes can also be marked. When an intermediate node is marked, it signifies that it has child nodes that have been marked.
+/// **Copy-on-write (COW):** If items within `XArray` implement the `Clone` trait, cloning can leverage a COW mechanism.
+/// A clone of an `XArray` initially shares the head node with the original, avoiding immediate deep copying.
+/// If a mutable operation is required on either `XArray`, a deep copy of the relevant `XNode` is made first, ensuring isolated operations.
+///
+/// **Cursors:** Interaction with `XArray` is mediated through `Cursor` and `CursorMut`.
+/// A `Cursor` requires an immutable reference, while `CursorMut` requires a mutable reference.
+/// As such, multiple `Cursor` instances can coexist, but `CursorMut` operations are singular,
+/// reflecting the behavior of shared (`&`) and exclusive (`&mut`) references.
+/// Cursors offer precise index positioning and traversal capabilities in the `XArray`.
+///
+/// **Marking:** `XArray` enables marking of individual items or the `XArray` itself for user convenience.
+/// Items and the `XArray` can have up to three distinct marks by default, with each mark independently maintained.
+/// Marks are generally enums implementing the `ValidMark` trait. Marking is also applicable to internal nodes,
+/// indicating marked descendant nodes, though such marking remains transparent to users.
 ///
 /// # Example
 ///
@@ -52,6 +54,7 @@ where
     I: ItemEntry,
     M: ValidMark,
 {
+    marks: [bool; 3],
     head: XEntry<I>,
     _marker: PhantomData<(I, M)>,
 }
@@ -60,11 +63,27 @@ impl<I: ItemEntry, M: ValidMark> XArray<I, M> {
     /// Make a new, empty XArray.
     pub const fn new() -> Self {
         Self {
+            marks: [false; 3],
             head: XEntry::EMPTY,
             _marker: PhantomData,
         }
     }
 
+    /// Mark the `XArray` with the input `mark`.
+    pub fn set_mark(&mut self, mark: M) {
+        self.marks[mark.index()] = true;
+    }
+
+    /// Unset the input `mark` for the `XArray`.
+    pub fn unset_mark(&mut self, mark: M) {
+        self.marks[mark.index()] = false;
+    }
+
+    /// Judge if the `XArray` is marked with the input `mark`.
+    pub fn is_marked(&self, mark: M) -> bool {
+        self.marks[mark.index()]
+    }
+
     /// Return a reference to the head entry, and later will not modify the XNode pointed to by the `head`.
     pub(crate) fn head(&self) -> &XEntry<I> {
         &self.head
@@ -99,20 +118,14 @@ impl<I: ItemEntry, M: ValidMark> XArray<I, M> {
     /// If the target item exists, return it with `Some`, Otherwise, return `None`.
     pub fn load(&self, index: u64) -> Option<&I> {
         let mut cursor = self.cursor(index);
-        let entry = cursor.load();
-        if entry.is_some_and(|entry| entry.is_item()) {
-            entry.map(|entry| unsafe { &*(entry as *const XEntry<I> as *const I) })
-        } else {
-            None
-        }
+        cursor.load()
     }
 
     /// Stores the provided item in the `XArray` at the target index,
     /// and return the old item if it was previously stored in target index.
     pub fn store(&mut self, index: u64, item: I) -> Option<I> {
-        let stored_entry = XEntry::from_item(item);
-        let old_entry = self.cursor_mut(index).store(stored_entry);
-        XEntry::into_item(old_entry)
+        let mut cursor = self.cursor_mut(index);
+        cursor.store(item)
     }
 
     /// Attempts to load the item and its mark information about input `mark` at the target index within the `XArray`.
@@ -125,52 +138,22 @@ impl<I: ItemEntry, M: ValidMark> XArray<I, M> {
         } else {
             None
         };
-        if entry.is_some_and(|entry| entry.is_item()) {
-            entry.map(|entry| {
-                (
-                    unsafe { &*(entry as *const XEntry<I> as *const I) },
-                    mark.unwrap(),
-                )
-            })
-        } else {
-            None
-        }
+        entry.map(|entry| (entry, mark.unwrap()))
     }
 
     /// Stores the provided item in the `XArray` at the target index and mark it with input `mark`.
     /// and return the old item if it was previously stored in target index.
     pub fn store_with_mark(&mut self, index: u64, item: I, mark: M) -> Option<I> {
-        let stored_entry = XEntry::from_item(item);
         let mut cursor = self.cursor_mut(index);
-        let old_entry = cursor.store(stored_entry);
+        let old_item = cursor.store(item);
         cursor.set_mark(mark).unwrap();
-        XEntry::into_item(old_entry)
-    }
-
-    /// Mark the item at the target index in the `XArray` with the input `mark`.
-    /// If the item does not exist, return an Error.
-    pub fn set_mark(&mut self, index: u64, mark: M) -> Result<(), ()> {
-        self.cursor_mut(index).set_mark(mark)
-    }
-
-    /// Unset the input `mark` for the item at the target index in the `XArray`.
-    /// If the item does not exist, return an Error.
-    pub fn unset_mark(&mut self, index: u64, mark: M) -> Result<(), ()> {
-        self.cursor_mut(index).unset_mark(mark)
-    }
-
-    /// Obtain a reference to the XEntry from a pointer pointing to it.
-    ///
-    /// # Safety
-    /// The user must ensure that the pointer remains valid for the duration of use of the target XEntry reference.
-    pub(crate) unsafe fn ref_entry(&self, entry_ptr: *const XEntry<I>) -> &XEntry<I> {
-        &*entry_ptr
+        old_item
     }
 
     /// 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();
-        if let Some(node) = self.head.as_node_mut() {
+        if let Some(node) = self.head_mut().as_node_mut() {
             handle_list.push_back(node);
         }
         while !handle_list.is_empty() {
@@ -179,8 +162,7 @@ impl<I: ItemEntry, M: ValidMark> XArray<I, M> {
             let node_mark = node.mark(mark.index());
             while (offset as usize) < SLOT_SIZE {
                 if node_mark.is_marked(offset) {
-                    // Safety: During this operation, the used XNode will not be removed and rge referenced XEntry must be valid.
-                    let entry = unsafe { self.ref_entry(node.entry(offset)) };
+                    let entry = node.ref_node_entry(offset);
                     if let Some(node) = entry.as_node_mut() {
                         handle_list.push_back(node);
                     }
@@ -194,17 +176,17 @@ impl<I: ItemEntry, M: ValidMark> XArray<I, M> {
     /// Removes the `XEntry` at the target index within the `XArray`,
     /// and return the removed item if it was previously stored in target index.
     pub fn remove(&mut self, index: u64) -> Option<I> {
-        let old_entry = self.cursor_mut(index).remove();
-        XEntry::into_item(old_entry)
+        let mut cursor = self.cursor_mut(index);
+        cursor.remove()
     }
 
     /// Create an `Cursor` to perform read related operations on the `XArray`.
-    pub(crate) fn cursor<'a>(&'a self, index: u64) -> Cursor<'a, I, M> {
+    pub fn cursor<'a>(&'a self, index: u64) -> Cursor<'a, I, M> {
         Cursor::new(self, index)
     }
 
     /// Create an `CursorMut` to perform read and write operations on the `XArray`.
-    pub(crate) fn cursor_mut<'a>(&'a mut self, index: u64) -> CursorMut<'a, I, M> {
+    pub fn cursor_mut<'a>(&'a mut self, index: u64) -> CursorMut<'a, I, M> {
         CursorMut::new(self, index)
     }
 }
@@ -214,6 +196,7 @@ impl<I: ItemEntry + Clone, M: ValidMark> Clone for XArray<I, M> {
     fn clone(&self) -> Self {
         let cloned_head = self.head.clone();
         Self {
+            marks: self.marks,
             head: cloned_head,
             _marker: PhantomData,
         }