Optimize implementation details and code soundness.

README.md

@@ -1,2 +1,160 @@
-# XArray
-An XArray struct implemented by Rust.
+# XArray 
+
+`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
+
+- **Cursors:** Provide cursors for precise and efficient iteration over the array. Cursors have both immutable and mutable versions. One can hold multiple immutable cursors or hold a mutable cursor exclusively at a time. 
+- **Marking:** Provide ability to mark entries and the XArray itself for easy state tracking.
+- **Generics:** Generic implementation that can work with any entry type and any inner locks that fits the use case.
+- **Copy-on-Write (COW):** Efficient cloning of XArrays with shared structure until mutation.
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+xarray = "0.1.0"
+```
+
+## Usage
+This crate is developed in `no_std` environment, but std users can still use this crate with `--feature="std"`:
+
+The following section covers how to interact with `XArray` including creating an `XArray`, using cursors, marking, cloning, and more.
+
+### Creating an `XArray`:
+- Users should declare the type of items (Arc<i32>) stored in the XArray and the lock (StdMutex) used inside the XArray. Note that `StdMutex` is an abstraction for `std::sync::Mutex`.
+- The type of stored item must implement `ItemEntry` trait and the used lock abstraction must be generated by the macro `abstract_lock_to!`. The real lock type that be abstracted should implement `ValidLock` trait.
+- We implement `ItemEntry` for `alloc::sync::Arc` and `alloc::sync::Box` by default, and abstract `std::sync::Mutex` and `std::sync::RwLock` as `StdMutex` and `StdRwLock` for std users, respectively
+
+```rust
+extern crate alloc;
+
+use alloc::sync::Arc;
+use xarray::{XArray, StdMutex};
+
+// Create a new XArray instance
+let mut xarray: XArray<Arc<i32>, StdMutex> = XArray::new();
+```
+
+### Using Cursor
+```rust
+extern crate alloc;
+
+use alloc::sync::Arc;
+use xarray::{XArray, StdMutex};
+
+let mut xarray_arc: XArray<Arc<i32>, StdMutex> = XArray::new();
+
+let mut cursor = xarray_arc.cursor_mut(0);
+// Store the Arc at the index range 0~10000.
+for i in 0..10000 {
+    let value = Arc::new(i * 2);
+    cursor.store(value);
+    cursor.next();
+}
+
+cursor.reset_to(0);
+for i in 0..10000 {
+    let value = cursor.load().unwrap();
+    assert!(*value.as_ref() == i * 2);
+    cursor.next();
+}
+```
+### Using Marks
+- Items and the `XArray` can have up to three distinct marks by default, with each mark independently maintained.
+- Users need to use a struct to represent the marks that need to be used. For the situation where multiple marks are required, these marks are typically encapsulated within an enumeration class.
+- This struct for marks should implement `Into<XMark>` trait and be declared in the generics list of XArray.
+
+```rust
+extern crate alloc;
+
+use alloc::sync::Arc;
+use xarray::{XArray, XMark, StdMutex};
+
+#[derive(Clone, Copy)]
+enum MarkDemo {
+    Mark0,
+    Mark1,
+    Mark2,
+}
+
+impl Into<XMark> for MarkDemo {
+    fn into(self) -> XMark {
+        match self {
+            MarkDemo::Mark0 => XMark::Mark0,
+            MarkDemo::Mark1 => XMark::Mark1,
+            MarkDemo::Mark2 => XMark::Mark2,
+        }
+    }
+}
+
+let mut xarray_arc: XArray<Arc<i32>, StdMutex, MarkDemo> = XArray::new();
+// Mark the xarray with Mark1.
+xarray_arc.set_mark(MarkDemo::Mark0);
+assert!(xarray_arc.is_marked(MarkDemo::Mark0));
+
+let mut cursor = xarray_arc.cursor_mut(1000);
+let value = Arc::new(i * 2);
+cursor.store(value);
+
+// Mark the item with Mark1.
+cursor.set_mark(MarkDemo::Mark1).unwrap();
+assert!(cursor.is_marked(MarkDemo::Mark1));
+```
+
+### Copy-On-Write (COW) Clone
+```rust
+use std::sync::Arc;
+use xarray::{XArray, StdMutex};
+
+let mut xarray: XArray<Arc<i32>, StdMutex> = XArray::new();
+
+// Store values
+let value = Arc::new(10);
+xarray.store(333, value.clone());
+assert_eq!(*xarray.load(333).unwrap().as_ref(), 10);
+
+// Clone the XArray
+let mut xarray_clone = xarray.clone();
+assert_eq!(*xarray_clone.load(333).unwrap().as_ref(), 10);
+
+// Store a new value in the clone
+let new_value = Arc::new(100);
+xarray_clone.store(333, new_value);
+
+// The original XArray is unaffected by changes in the clone
+assert_eq!(*xarray.load(333).unwrap().as_ref(), 10);
+assert_eq!(*xarray_clone.load(333).unwrap().as_ref(), 100);
+```
+
+### Iteration
+```rust
+use std::sync::Arc;
+use xarray::{XArray, StdMutex};
+
+let mut xarray: XArray<Arc<i32>, StdMutex> = XArray::new();
+
+// Store item to even index in the range 100~200.
+for i in 100..200 {
+    if i % 2 == 0 {
+        let value = Arc::new(i * 2);
+        cursor.store(value);
+    }
+    cursor.next();
+}
+
+// Iterate at the range 100~200.
+let mut count = 0;
+for item in xarray.range(100..200) {
+    count += 1;
+}
+assert_eq!(count == 50);
+```
+
+## License
+
+

src/cow.rs

@@ -1,43 +1,28 @@
-use super::*;
+use crate::entry::{ItemEntry, XEntry};
+use crate::lock::XLock;
+use crate::node::deep_clone_node_entry;
 
-/// 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.
+/// 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, entry: &XEntry<I, L>) -> Option<XEntry<I, L>>;
+    fn copy_if_shared(&self) -> Option<XEntry<I, L>>;
 }
 
-impl<I: ItemEntry, L: XLock> Cow<I, L> for XNode<I, L, ReadWrite> {
-    default fn copy_if_shared(&self, _entry: &XEntry<I, L>) -> 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 XNode<I, L, ReadWrite> {
-    fn copy_if_shared(&self, entry: &XEntry<I, L>) -> Option<XEntry<I, L>> {
-        copy_if_shared(entry)
-    }
-}
-
-impl<I: ItemEntry, L: XLock, M: ValidMark> Cow<I, L> for XArray<I, L, M> {
-    default fn copy_if_shared(&self, _entry: &XEntry<I, L>) -> Option<XEntry<I, L>> {
-        None
-    }
-}
-
-impl<I: ItemEntry + Clone, L: XLock, M: ValidMark> Cow<I, L> for XArray<I, L, M> {
-    fn copy_if_shared(&self, entry: &XEntry<I, L>) -> Option<XEntry<I, L>> {
-        copy_if_shared(entry)
-    }
-}
-
-fn copy_if_shared<I: ItemEntry + Clone, L: XLock>(entry: &XEntry<I, L>) -> Option<XEntry<I, L>> {
-    if entry.is_node() && entry.node_strong_count().unwrap() > 1 {
-        let new_entry = deep_clone_node_entry(entry);
-        Some(new_entry)
-    } else {
-        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_clone_node_entry(self);
+            Some(new_entry)
+        } else {
+            None
+        }
     }
 }

src/cursor.rs

@@ -1,8 +1,12 @@
 use smallvec::SmallVec;
 
-use super::*;
+use crate::entry::{ItemEntry, XEntry};
+use crate::lock::XLock;
+use crate::mark::XMark;
+use crate::node::{Height, ReadOnly, ReadWrite, XNode};
+use crate::xarray::{XArray, MAX_HEIGHT, SLOT_SIZE};
 use core::marker::PhantomData;
-use core::ops::{Deref, DerefMut};
+use core::ops::Deref;
 
 /// 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.
@@ -55,18 +59,21 @@ impl<'a, I: ItemEntry, L: XLock, Operation> CursorState<'a, I, L, Operation> {
     }
 }
 
-/// 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
+/// 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 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,
+/// 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`.
 ///
-/// Hence, at any given moment when no operation is being performed, 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`.
+/// Hence, at any given moment when no operation is being performed, 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.
@@ -76,7 +83,7 @@ pub struct Cursor<'a, I, L, M>
 where
     I: ItemEntry,
     L: XLock,
-    M: ValidMark,
+    M: Into<XMark>,
 {
     /// The `XArray` the cursor located in.
     xa: &'a XArray<I, L, M>,
@@ -91,7 +98,7 @@ where
     _marker: PhantomData<I>,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
+impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> Cursor<'a, I, L, 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 {
         let mut cursor = Self {
@@ -106,19 +113,26 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
         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 (current_entry, offset) = {
-            let offset = node.entry_offset(self.index);
-            let current_entry = node.ref_node_entry(offset);
-            (current_entry, offset)
-        };
+        let offset = node.entry_offset(self.index);
         self.state.arrive_node(node, offset);
-        current_entry
+        self.ref_operated_entry().unwrap()
     }
 
-    /// Reset the target index of the Cursor. Once set, it will immediately attempt to move the Cursor to touch the target XEntry.
+    /// 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;
@@ -126,8 +140,8 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
     }
 
     /// 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`.
+    /// 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;
@@ -155,7 +169,7 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
         self.state.arrive_node(current_node, operation_offset);
 
         while !current_node.is_leaf() {
-            let next_entry = current_node.ref_node_entry(operation_offset);
+            let next_entry = self.ref_operated_entry().unwrap();
             if !next_entry.is_node() {
                 self.init();
                 return;
@@ -164,17 +178,17 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
             let next_node = next_entry.as_node().unwrap();
             self.ancestors.push(current_node);
             self.move_to(next_node);
-            (current_node, operation_offset) = self.state.node_info().unwrap();
+            current_node = next_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(&mut self, mark: M) -> Option<bool> {
+    pub fn is_marked(&self, mark: M) -> bool {
         if let Some((current_node, operation_offset)) = self.state.node_info() {
-            Some(current_node.is_marked(operation_offset, mark.index()))
+            current_node.is_marked(operation_offset, mark.into().index())
         } else {
-            None
+            false
         }
     }
 
@@ -182,10 +196,11 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, 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 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);
+    pub fn load(&self) -> Option<&'a I> {
+        if let Some(entry) = self.ref_operated_entry() {
             if entry.is_item() {
+                // SAFETY: If the XEntry is an item entry, its memory layout is guaranteed
+                // to be exactly the same as that of I.
                 return Some(unsafe { &*(entry as *const XEntry<I, L> as *const I) });
             }
         }
@@ -198,8 +213,7 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
     /// 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() {
-            let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return Some(current_node.ref_node_entry(operation_offset));
+            return self.ref_operated_entry();
         }
 
         let max_index = self.xa.max_index();
@@ -208,8 +222,8 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
         }
         self.move_to(self.xa.head().as_node().unwrap());
 
-        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
-        let mut operated_entry = current_node.ref_node_entry(operation_offset);
+        let (mut current_node, _) = self.state.node_info().unwrap();
+        let mut operated_entry = self.ref_operated_entry().unwrap();
         while !current_node.is_leaf() {
             if !operated_entry.is_node() {
                 self.init();
@@ -230,46 +244,59 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> Cursor<'a, I, L, M> {
     }
 
     /// Return the target index of the cursor.
-    pub fn index(&mut self) -> u64 {
+    pub fn index(&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.
-    pub fn is_arrived(&mut self) -> bool {
+    /// 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()
     }
 }
 
-/// 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
+/// 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 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 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`.  
 ///
-/// Hence, at any given moment when no operation is being performed, 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`
+/// When CursorMut performs `reset_to()` and `next()` methods and moves its index,
+/// the CursorMut will no longer be exclusive.
+///
+/// Hence, at any given moment when no operation is being performed, 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.
+/// 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 if it is exclusive, 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.
-/// CursorMut is set to exclusive when a modification is about to be performed
+/// **Features for COW (Copy-On-Write).** The CursorMut guarantees that if it is exclusive,
+/// 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. CursorMut is set to exclusive when a modification
+/// is about to be performed
 ///
-/// When a CursorMut doing write operation on XArray, it should not be affected by other CursorMuts or affect other Cursors.
+/// 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>
 where
     I: ItemEntry,
     L: XLock,
-    M: ValidMark,
+    M: Into<XMark>,
 {
     /// The `XArray` the cursor located in.
     xa: &'a mut XArray<I, L, M>,
@@ -286,7 +313,7 @@ where
     _marker: PhantomData<I>,
 }
 
-impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
+impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> CursorMut<'a, I, L, 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 {
         let mut cursor = Self {
@@ -302,26 +329,66 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
         cursor
     }
 
+    /// Get a reference to current operated entry of the CursorMut.
+    fn ref_operated_entry(&self) -> Option<&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>) -> &'a XEntry<I, L> {
-        let (current_entry, offset) = {
-            let offset = node.entry_offset(self.index);
-            let current_entry = node.ref_node_entry(self.is_exclusive, offset);
-            (current_entry, offset)
-        };
+    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);
-        current_entry
+        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;
     }
 
-    /// Reset the target index of the Cursor. Once set, it will immediately attempt to move the Cursor to touch the target XEntry.
+    /// 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.is_exclusive = false;
         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<&I> {
+        if let Some(entry) = self.ref_operated_entry() {
+            if entry.is_item() {
+                // SAFETY: If the XEntry is an item entry, its memory layout is guaranteed
+                // to be exactly the same as that of I.
+                return Some(unsafe { &*(entry as *const XEntry<I, L> as *const I) });
+            }
+        }
+        None
+    }
+
     /// 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,
@@ -340,11 +407,13 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
     }
 
     /// 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`.
+    /// 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;
+        self.is_exclusive = false;
         if !self.is_arrived() {
             return;
         }
@@ -369,40 +438,44 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
         self.state.arrive_node(current_node, operation_offset);
 
         while !current_node.is_leaf() {
-            let next_entry = current_node.ref_node_entry(self.is_exclusive, operation_offset);
+            self.ancestors.push(current_node);
+            let next_entry = self.ref_operated_entry().unwrap();
             if !next_entry.is_node() {
                 self.init();
                 return;
             }
 
-            let next_node = next_entry.as_node_mut().unwrap();
-            self.ancestors.push(current_node);
+            // 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, operation_offset) = self.state.node_info().unwrap();
+            (current_node, _) = self.state.node_info().unwrap();
         }
     }
 
     /// Mark the item at the target index in the `XArray` with the input `mark`.
     /// If the item does not exist, return an Error.
     ///
-    /// 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.
+    /// 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 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 = current_node.ref_node_entry(self.is_exclusive, operation_offset);
+            let item_entry = self.ref_operated_entry().unwrap();
             if item_entry.is_null() {
                 return Err(());
             }
 
-            current_node.set_mark(operation_offset, mark.index());
+            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()) {
+                if ancestor.is_marked(offset_in_parent, mark_index) {
                     break;
                 }
-                ancestor.set_mark(offset_in_parent, mark.index());
+                ancestor.set_mark(offset_in_parent, mark_index);
                 offset_in_parent = ancestor.offset_in_parent();
             }
             Ok(())
@@ -414,23 +487,24 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
     /// Unset the input `mark` for the item at the target index in the `XArray`.
     /// If the item does not exist, return an Error.
     ///
-    /// 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.
+    /// 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 = current_node.ref_node_entry(self.is_exclusive, operation_offset);
+            let item_entry = self.ref_operated_entry().unwrap();
             if item_entry.is_null() {
                 return Err(());
             }
 
-            current_node.unset_mark(operation_offset, mark.index());
+            let mark_index = mark.into().index();
+            current_node.unset_mark(operation_offset, mark_index);
 
-            if current_node.is_mark_clear(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()) {
+                    ancestor.unset_mark(offset_in_parent, mark_index);
+                    if !ancestor.is_mark_clear(mark_index) {
                         break;
                     }
 
@@ -460,33 +534,39 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> 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.
     /// If can not touch the target entry, the function will return `None`.
-    fn traverse_to_target(&mut self) -> Option<&'a XEntry<I, L>> {
+    fn traverse_to_target(&mut self) -> Option<&XEntry<I, L>> {
         if self.is_arrived() {
-            let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return Some(current_node.ref_node_entry(self.is_exclusive, operation_offset));
+            return self.ref_operated_entry();
         }
 
         let max_index = self.xa.max_index();
         if max_index < self.index || max_index == 0 {
             return None;
         }
-        let head = self.xa.head_mut(self.is_exclusive).as_node_mut().unwrap();
-        self.move_to(head);
 
-        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
-        let mut operated_entry = current_node.ref_node_entry(self.is_exclusive, operation_offset);
+        if self.is_exclusive {
+            self.xa.ensure_head_exclusive();
+        }
+
+        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;
             }
-
-            self.ancestors.push(current_node);
-
-            current_node = operated_entry.as_node_mut().unwrap();
-            operated_entry = self.move_to(current_node);
+            // 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);
         }
-        Some(operated_entry)
+        self.ref_operated_entry()
     }
 
     /// Traverse the XArray and move to the node that can operate the target entry.
@@ -497,45 +577,53 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> 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) -> &'a XEntry<I, L> {
+    fn expand_and_traverse_to_target(&mut self) -> &XEntry<I, L> {
         if self.is_arrived() {
-            let (current_node, operation_offset) = self.state.node_info().unwrap();
-            return current_node.ref_node_entry(self.is_exclusive, operation_offset);
+            return self.ref_operated_entry().unwrap();
         }
 
         self.expand_height();
-        let head_ref = self.xa.head_mut(self.is_exclusive).as_node_mut().unwrap();
-        self.move_to(head_ref);
 
-        let (mut current_node, operation_offset) = self.state.node_info().unwrap();
-        let mut operated_entry = current_node.ref_node_entry(self.is_exclusive, operation_offset);
+        if self.is_exclusive {
+            self.xa.ensure_head_exclusive();
+        }
+
+        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 mut operated_entry = self.ref_operated_entry().unwrap();
             let current_height = current_node.height();
 
             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(Height::new(*current_height - 1), operation_offset);
-                    let _ = current_node.set_entry(operation_offset, new_owned_entry);
-                    current_node.ref_node_entry(self.is_exclusive, operation_offset)
-                };
-                operated_entry = new_entry;
+                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) };
             }
+            // 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.ancestors.push(current_node);
-
-            current_node = operated_entry.as_node_mut().unwrap();
-            operated_entry = self.move_to(current_node);
+            self.move_to(current_node);
         }
-        operated_entry
+        self.ref_operated_entry().unwrap()
     }
 
-    /// 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.
+    /// 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.
+    /// 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);
@@ -548,7 +636,10 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
         } else {
             loop {
                 let head_height = {
-                    let head = self.xa.head_mut(self.is_exclusive).as_node().unwrap();
+                    if self.is_exclusive {
+                        self.xa.ensure_head_exclusive();
+                    }
+                    let head = self.xa.head().as_node().unwrap();
                     head.height()
                 };
 
@@ -559,7 +650,7 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
                 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_mut(self.is_exclusive).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);
@@ -577,26 +668,55 @@ impl<'a, I: ItemEntry, L: XLock, M: ValidMark> CursorMut<'a, I, L, M> {
     }
 
     fn ensure_exclusive_before_modify(&mut self) {
-        if !self.is_exclusive {
+        if self.is_exclusive {
+            return;
+        }
+
+        if !self.is_arrived() {
             self.is_exclusive = true;
-            if self.is_arrived() {
-                self.init();
-                self.traverse_to_target();
+            return;
+        }
+
+        if self.xa.head().node_strong_count().unwrap() > 1 {
+            self.init();
+            self.is_exclusive = true;
+            self.traverse_to_target();
+            return;
+        }
+
+        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);
+                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: ValidMark> Deref for CursorMut<'a, I, L, M> {
+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, L: XLock, M: ValidMark> DerefMut for CursorMut<'a, I, L, M> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe { &mut *(self as *const CursorMut<'a, I, L, M> as *mut Cursor<'a, I, L, M>) }
-    }
-}

src/entry.rs

@@ -3,15 +3,17 @@ use alloc::sync::Arc;
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
 
-use super::*;
+use crate::lock::XLock;
+use crate::node::{ReadWrite, XNode};
+use crate::xarray::SLOT_SIZE;
 
 /// 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.
 ///
 /// # Safety
-/// Users must ensure that the produced `usize` of `into_raw()` meets the requirements for an item entry in the XArray. Specifically,
-/// if the original type is a pointer, the last two bits should be 00; if the original
-/// type is a value like usize, the last bit should be 1 (TODO).
+/// Users must ensure that the produced `usize` of `into_raw()` meets the requirements for an item entry
+/// in the XArray. Specifically, if the original type is a pointer, the last two bits should be 00;
+/// if the original type is a value like usize, the last bit should be 1 (TODO).
 pub unsafe trait ItemEntry {
     /// Converts the original type into a `usize`, consuming the ownership of the original type.
     ///
@@ -28,6 +30,7 @@ pub unsafe trait ItemEntry {
 
 unsafe impl<T> ItemEntry for Arc<T> {
     fn into_raw(self) -> usize {
+        // SAFETY: The Arc<T> have the same layout with a raw pointer hence the transmute is valid.
         let raw_ptr = unsafe { core::intrinsics::transmute::<Arc<T>, *const u8>(self) };
         debug_assert!(raw_ptr.is_aligned_to(4));
         raw_ptr as usize
@@ -51,10 +54,12 @@ unsafe impl<T> ItemEntry for Box<T> {
     }
 }
 
-/// The type stored in the head of `XArray` and the slots of `XNode`s, which is the basic unit of storage within an XArray.
+/// The type stored in the head of `XArray` and the slots of `XNode`s, which is the basic unit of storage
+/// within an XArray.
+///
 /// There are the following types of `XEntry`:
-/// - Internal entries: These are invisible to users and have the last two bits set to 10. Currently `XArray` only have node
-/// entries as internal entries, which are entries that point to XNodes.
+/// - Internal entries: These are invisible to users and have the last two bits set to 10. Currently `XArray`
+/// only have node entries as internal entries, which are entries that point to XNodes.
 /// - Item entries: Items stored by the user. Currently stored items can only be pointers and the last two bits
 /// of these item entries are 00.
 ///
@@ -121,6 +126,10 @@ impl<I: ItemEntry, L: XLock> XEntry<I, L> {
 
     pub const EMPTY: Self = unsafe { Self::new(0) };
 
+    /// 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 {
         Self {
             raw,
@@ -178,7 +187,7 @@ impl<I: ItemEntry, L: XLock> XEntry<I, L> {
         }
     }
 
-    pub fn as_node_mut<'a>(&self) -> Option<&'a XNode<I, L, ReadWrite>> {
+    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>);
@@ -192,12 +201,10 @@ impl<I: ItemEntry, L: XLock> XEntry<I, L> {
     pub fn node_strong_count(&self) -> Option<usize> {
         if self.is_node() {
             let raw_ptr = (self.raw - 2) as *const u8;
-            unsafe {
-                let arc = Arc::from_raw(raw_ptr);
-                let strong_count = Arc::strong_count(&arc);
-                core::mem::forget(arc);
-                Some(strong_count)
-            }
+            let arc = unsafe { Arc::from_raw(raw_ptr) };
+            let strong_count = Arc::strong_count(&arc);
+            core::mem::forget(arc);
+            Some(strong_count)
         } else {
             None
         }

src/lib.rs

@@ -3,51 +3,29 @@
 #![feature(pointer_is_aligned)]
 #![feature(specialization)]
 #![feature(associated_type_defaults)]
+#![feature(never_type)]
+#![feature(test)]
 
 extern crate alloc;
-extern crate smallvec;
 
+pub use cursor::{Cursor, CursorMut};
+pub use entry::ItemEntry;
+pub use lock::{ValidLock, XLock};
+pub use mark::XMark;
+pub use range::Range;
+pub use xarray::XArray;
 
-pub use cursor::*;
-pub use entry::*;
-pub use mark::*;
-pub use xarray::*;
-
-use cow::*;
-use node::*;
+#[cfg(feature = "std")]
+pub use lock::std_specific::*;
 
 mod cow;
 mod cursor;
 mod entry;
+mod lock;
 mod mark;
 mod node;
+mod range;
 mod xarray;
 
 #[cfg(all(test, feature = "std"))]
 mod test;
-
-#[cfg(feature = "std")]
-pub use std_specific::*;
-
-#[cfg(feature = "std")]
-mod std_specific {
-    extern crate std;
-
-    use crate::*;
-    use std::sync::{Mutex, MutexGuard};
-
-    impl<T> ValidLock<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/lock.rs

@@ -0,0 +1,66 @@
+use core::ops::{Deref, DerefMut};
+
+/// ValidLock is a trait that needs to be implemented for locks used internally within XArray.
+/// It abstracts the functionalities of the necessary locks inside.
+pub trait ValidLock<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-Kinded Type) abstraction of ValidLock 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-kinded 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>: ValidLock<T>;
+
+    fn new<T>(inner: T) -> Self::Lock<T> {
+        Self::Lock::<T>::new(inner)
+    }
+}
+
+#[macro_export]
+/// Abstract a lock type that implements `ValidLock` 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_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> ValidLock<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

@@ -34,18 +34,24 @@ impl Mark {
     }
 }
 
-// In XArray, an item can have up to three different marks. Users can use a type to distinguish
-// which kind of mark they want to set. Such a type must implement the `ValidMark` trait,
-// meaning it should be convertible to an index in the range of 0 to 2.
-pub trait ValidMark: Copy + Clone {
-    /// Map the self type to an index in the range 0 to 2.
-    fn index_raw(&self) -> usize;
-
-    /// Users are not required to implement this; it ensures that the mapped index does not exceed 2.
-    fn index(&self) -> usize {
-        let index = self.index_raw();
-        debug_assert!(index < 3);
-        index
+/// The mark type used in the XArray. The XArray itself and an item in it can have up to three different marks.
+///
+/// Users can use a self-defined type to distinguish which kind of mark they want to set.
+/// Such a type must implement the `Into<XMark>` trait,
+pub enum XMark {
+    Mark0,
+    Mark1,
+    Mark2,
+}
+
+impl XMark {
+    /// Map the XMark to an index in the range 0 to 2.
+    pub(super) fn index(&self) -> usize {
+        match self {
+            XMark::Mark0 => 0,
+            XMark::Mark1 => 1,
+            XMark::Mark2 => 2,
+        }
     }
 }
 
@@ -54,8 +60,8 @@ pub trait ValidMark: Copy + Clone {
 #[derive(Clone, Copy)]
 pub struct NoneMark {}
 
-impl ValidMark for NoneMark {
-    fn index_raw(&self) -> usize {
-        0
+impl Into<XMark> for NoneMark {
+    fn into(self) -> XMark {
+        panic!("NoneMark can not be used!");
     }
 }

src/node.rs

@@ -4,7 +4,11 @@ use core::{
     ops::{Deref, DerefMut},
 };
 
-use super::*;
+use crate::cow::Cow;
+use crate::entry::{ItemEntry, XEntry};
+use crate::lock::{ValidLock, XLock};
+use crate::mark::Mark;
+use crate::xarray::{BITS_PER_LAYER, SLOT_MASK, SLOT_SIZE};
 
 pub(super) struct ReadOnly {}
 pub(super) struct ReadWrite {}
@@ -140,12 +144,14 @@ impl<I: ItemEntry, L: XLock, Operation> XNode<I, L, Operation> {
 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.
-    pub fn ref_node_entry(&self, offset: u8) -> &XEntry<I, L> {
+    ///
+    /// # 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>;
-        // 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 { &*entry_ptr }
     }
 }
@@ -153,20 +159,22 @@ impl<I: ItemEntry, L: XLock> XNode<I, L, ReadOnly> {
 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.
-    pub fn ref_node_entry<'a>(&self, is_exclusive: bool, offset: u8) -> &XEntry<I, L> {
+    ///
+    /// # 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) = self.copy_if_shared(&lock.slots[offset as usize]) {
+            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>;
-        // 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 { &*entry_ptr }
     }
 

src/range.rs

@@ -0,0 +1,44 @@
+use crate::cursor::Cursor;
+use crate::entry::ItemEntry;
+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>
+where
+    I: ItemEntry,
+    L: XLock,
+    M: Into<XMark>,
+{
+    cursor: Cursor<'a, I, L, 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>, end: u64) -> Self {
+        Range { cursor, end }
+    }
+}
+
+impl<'a, I: ItemEntry, L: XLock, M: Into<XMark>> core::iter::Iterator for Range<'a, I, L, M> {
+    type Item = (u64, &'a I);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.cursor.index() >= self.end {
+                return None;
+            }
+
+            let item = self.cursor.load();
+            if item.is_none() {
+                self.cursor.next();
+                continue;
+            }
+
+            let res = item.map(|item| (self.cursor.index(), item));
+            self.cursor.next();
+            return res;
+        }
+    }
+}

src/test.rs

@@ -2,6 +2,9 @@ extern crate std;
 use crate::*;
 use std::sync::Arc;
 
+extern crate test;
+use test::Bencher;
+
 #[derive(Clone, Copy)]
 enum MarkDemo {
     Mark0,
@@ -9,12 +12,12 @@ enum MarkDemo {
     Mark2,
 }
 
-impl ValidMark for MarkDemo {
-    fn index_raw(&self) -> usize {
+impl Into<XMark> for MarkDemo {
+    fn into(self) -> XMark {
         match self {
-            Self::Mark0 => 0,
-            Self::Mark1 => 1,
-            Self::Mark2 => 2,
+            Self::Mark0 => XMark::Mark0,
+            Self::Mark1 => XMark::Mark1,
+            Self::Mark2 => XMark::Mark2,
         }
     }
 }
@@ -79,11 +82,21 @@ fn test_mark() {
     assert!(Err(()) == cursor.set_mark(MarkDemo::Mark1));
     assert!(None == cursor.load());
     drop(cursor);
-    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();
-    let (_, value2_mark0) = xarray_arc.load_with_mark(2000, MarkDemo::Mark0).unwrap();
-    let (value3, value3_mark1) = xarray_arc.load_with_mark(3000, MarkDemo::Mark1).unwrap();
+
+    let mut cursor = xarray_arc.cursor(1000);
+    let value1 = cursor.load().unwrap();
+    let value1_mark0 = cursor.is_marked(MarkDemo::Mark0);
+    let value1_mark1 = cursor.is_marked(MarkDemo::Mark1);
+
+    cursor.reset_to(2000);
+    let value2 = cursor.load().unwrap();
+    let value2_mark0 = cursor.is_marked(MarkDemo::Mark0);
+    let value2_mark1 = cursor.is_marked(MarkDemo::Mark1);
+
+    cursor.reset_to(3000);
+    let value3 = cursor.load().unwrap();
+    let value3_mark1 = cursor.is_marked(MarkDemo::Mark1);
+
     assert!(*value1.as_ref() == 2000);
     assert!(*value2.as_ref() == 4000);
     assert!(*value3.as_ref() == 6000);
@@ -92,18 +105,22 @@ fn test_mark() {
     assert!(value2_mark0 == false);
     assert!(value2_mark1 == true);
     assert!(value3_mark1 == false);
+    drop(cursor);
 
     let mut cursor = xarray_arc.cursor_mut(1000);
     cursor.unset_mark(MarkDemo::Mark0).unwrap();
     cursor.unset_mark(MarkDemo::Mark2).unwrap();
     drop(cursor);
-    let (_, value1_mark0) = xarray_arc.load_with_mark(1000, MarkDemo::Mark0).unwrap();
-    let (_, value1_mark2) = xarray_arc.load_with_mark(1000, MarkDemo::Mark2).unwrap();
+
+    let cursor = xarray_arc.cursor(1000);
+    let value1_mark0 = cursor.is_marked(MarkDemo::Mark0);
+    let value1_mark2 = cursor.is_marked(MarkDemo::Mark2);
     assert!(value1_mark0 == false);
     assert!(value1_mark2 == false);
+    drop(cursor);
 
     xarray_arc.unset_mark_all(MarkDemo::Mark1);
-    let (_, value2_mark1) = xarray_arc.load_with_mark(2000, MarkDemo::Mark1).unwrap();
+    let value2_mark1 = xarray_arc.cursor(2000).is_marked(MarkDemo::Mark1);
     assert!(value2_mark1 == false);
 }
 
@@ -163,6 +180,40 @@ fn test_cow() {
     assert!(INIT_TIMES.load(Ordering::Relaxed) == DROP_TIMES.load(Ordering::Relaxed));
 }
 
+#[test]
+fn test_cow_after_cow() {
+    let mut xarray_arc: XArray<Arc<u64>, StdMutex> = XArray::new();
+    for i in 1..10000 {
+        let value = Arc::new(i * 2);
+        xarray_arc.store(i as u64, value);
+    }
+    // First COW.
+    let mut xarray_cow1 = xarray_arc.clone();
+    for i in 5000..6000 {
+        let value = Arc::new(i * 3);
+        xarray_cow1.store(i as u64, value);
+    }
+    // Second COW.
+    let mut xarray_cow2 = xarray_arc.clone();
+    for i in 5500..7000 {
+        let value = Arc::new(i * 4);
+        xarray_cow2.store(i as u64, value);
+    }
+    // COW after COW.
+    let xarray_cow1_cow = xarray_cow1.clone();
+    let xarray_cow2_cow = xarray_cow2.clone();
+
+    assert!(*xarray_cow1_cow.load(2341).unwrap().as_ref() == 2341 * 2);
+    assert!(*xarray_cow1_cow.load(5100).unwrap().as_ref() == 5100 * 3);
+    assert!(*xarray_cow1_cow.load(5677).unwrap().as_ref() == 5677 * 3);
+    assert!(*xarray_cow1_cow.load(6315).unwrap().as_ref() == 6315 * 2);
+
+    assert!(*xarray_cow2_cow.load(2341).unwrap().as_ref() == 2341 * 2);
+    assert!(*xarray_cow2_cow.load(5100).unwrap().as_ref() == 5100 * 2);
+    assert!(*xarray_cow2_cow.load(5677).unwrap().as_ref() == 5677 * 4);
+    assert!(*xarray_cow2_cow.load(6315).unwrap().as_ref() == 6315 * 4);
+}
+
 #[test]
 fn test_cow_mark() {
     let mut xarray_arc: XArray<Arc<i32>, StdMutex, MarkDemo> = XArray::new();
@@ -182,14 +233,16 @@ fn test_cow_mark() {
     cursor_clone.set_mark(MarkDemo::Mark1).unwrap();
     drop(cursor_arc);
     drop(cursor_clone);
-    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();
-    let (_, mark1_1000_arc) = xarray_arc.load_with_mark(1000, MarkDemo::Mark1).unwrap();
-    let (_, mark0_1000_clone) = xarray_clone.load_with_mark(1000, MarkDemo::Mark0).unwrap();
-    let (_, mark0_2000_clone) = xarray_clone.load_with_mark(2000, MarkDemo::Mark0).unwrap();
-    let (_, mark1_1000_clone) = xarray_clone.load_with_mark(1000, MarkDemo::Mark1).unwrap();
-    let (_, mark0_3000_arc) = xarray_arc.load_with_mark(3000, MarkDemo::Mark0).unwrap();
-    let (_, mark0_3000_clone) = xarray_clone.load_with_mark(3000, MarkDemo::Mark0).unwrap();
+
+    let mark0_1000_arc = xarray_arc.cursor(1000).is_marked(MarkDemo::Mark0);
+    let mark0_2000_arc = xarray_arc.cursor(2000).is_marked(MarkDemo::Mark0);
+    let mark1_1000_arc = xarray_arc.cursor(1000).is_marked(MarkDemo::Mark1);
+    let mark0_3000_arc = xarray_arc.cursor(3000).is_marked(MarkDemo::Mark0);
+
+    let mark0_1000_clone = xarray_clone.cursor(1000).is_marked(MarkDemo::Mark0);
+    let mark0_2000_clone = xarray_clone.cursor(2000).is_marked(MarkDemo::Mark0);
+    let mark1_1000_clone = xarray_clone.cursor(1000).is_marked(MarkDemo::Mark1);
+    let mark0_3000_clone = xarray_clone.cursor(3000).is_marked(MarkDemo::Mark0);
 
     assert!(mark0_1000_arc == true);
     assert!(mark0_2000_arc == true);
@@ -226,6 +279,62 @@ fn test_next() {
     }
 }
 
+#[test]
+fn test_cow_next() {
+    let mut xarray_arc: XArray<Arc<u64>, StdMutex> = XArray::new();
+    for i in 1..10000 {
+        let value = Arc::new(i * 2);
+        xarray_arc.store(i as u64, value);
+    }
+    let mut xarray_clone = xarray_arc.clone();
+
+    let mut cursor_clone = xarray_clone.cursor_mut(1);
+    let mut cursor_arc = xarray_arc.cursor_mut(1);
+    // Use next to read xarray_clone;
+    while cursor_clone.index() < 10000 {
+        let item = cursor_clone.load().unwrap();
+        assert!(*item.as_ref() == cursor_clone.index() * 2);
+        cursor_clone.next();
+    }
+
+    // Use next to write xarray_clone;
+    cursor_clone.reset_to(1);
+    while cursor_clone.index() < 10000 {
+        let value = Arc::new(cursor_clone.index());
+        let item = cursor_clone.store(value).unwrap();
+        assert!(*item.as_ref() == cursor_clone.index() * 2);
+        cursor_clone.next();
+    }
+
+    // Use next to read xarray_arc;
+    while cursor_arc.index() < 10000 {
+        let item = cursor_arc.load().unwrap();
+        assert!(*item.as_ref() == cursor_arc.index() * 2);
+        cursor_arc.next();
+    }
+
+    // Use next to write xarray_arc;
+    cursor_arc.reset_to(1);
+    while cursor_arc.index() < 10000 {
+        let value = Arc::new(cursor_arc.index() * 3);
+        let item = cursor_arc.store(value).unwrap();
+        assert!(*item.as_ref() == cursor_arc.index() * 2);
+        cursor_arc.next();
+    }
+
+    // Use next to read xarray_arc and xarray_clone;
+    cursor_arc.reset_to(1);
+    cursor_clone.reset_to(1);
+    while cursor_arc.index() < 10000 {
+        let item_arc = cursor_arc.load().unwrap();
+        let item_clone = cursor_clone.load().unwrap();
+        assert!(*item_arc.as_ref() == cursor_arc.index() * 3);
+        assert!(*item_clone.as_ref() == cursor_clone.index());
+        cursor_arc.next();
+        cursor_clone.next();
+    }
+}
+
 #[test]
 fn test_range() {
     let mut xarray_arc: XArray<Arc<i32>, StdMutex> = XArray::new();
@@ -241,3 +350,8 @@ fn test_range() {
     }
     assert!(count == 500);
 }
+
+#[bench]
+fn benchmark_next(b: &mut Bencher) {
+    b.iter(|| test_next());
+}

src/xarray.rs

@@ -1,24 +1,30 @@
 use alloc::collections::VecDeque;
-use core::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-};
+use core::marker::PhantomData;
 
-use super::*;
+use crate::cow::Cow;
+use crate::cursor::{Cursor, CursorMut};
+use crate::entry::{ItemEntry, XEntry};
+use crate::lock::XLock;
+use crate::mark::{NoneMark, XMark};
+use crate::range::Range;
 
 pub(super) const BITS_PER_LAYER: usize = 6;
 pub(super) const SLOT_SIZE: usize = 1 << BITS_PER_LAYER;
 pub(super) const SLOT_MASK: usize = SLOT_SIZE - 1;
 pub(super) const MAX_HEIGHT: usize = 64 / BITS_PER_LAYER + 1;
 
-/// `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,
+/// `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 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.
+/// **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.
@@ -28,8 +34,9 @@ pub(super) const MAX_HEIGHT: usize = 64 / BITS_PER_LAYER + 1;
 ///
 /// **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.
+/// Users can use self-defined types as marks by implementing the `Into<XMark>` trait for them.
+/// Marking is also applicable to internal nodes, indicating marked descendant nodes,
+/// though such marking is not transparent to users.
 ///
 /// # Example
 ///
@@ -52,19 +59,20 @@ pub(super) const MAX_HEIGHT: usize = 64 / BITS_PER_LAYER + 1;
 /// assert!(*xarray_clone.load(333).unwrap().as_ref() == 100);
 /// ```
 ///
-/// 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, L: XLock, M = NoneMark>
+/// 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, L, M = NoneMark>
 where
     I: ItemEntry,
-    M: ValidMark,
+    L: XLock,
+    M: Into<XMark>,
 {
     marks: [bool; 3],
     head: XEntry<I, L>,
     _marker: PhantomData<(I, M)>,
 }
 
-impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
+impl<I: ItemEntry, L: XLock, M: Into<XMark>> XArray<I, L, M> {
     /// Make a new, empty XArray.
     pub const fn new() -> Self {
         Self {
@@ -76,17 +84,17 @@ impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
 
     /// Mark the `XArray` with the input `mark`.
     pub fn set_mark(&mut self, mark: M) {
-        self.marks[mark.index()] = true;
+        self.marks[mark.into().index()] = true;
     }
 
     /// Unset the input `mark` for the `XArray`.
     pub fn unset_mark(&mut self, mark: M) {
-        self.marks[mark.index()] = false;
+        self.marks[mark.into().index()] = false;
     }
 
     /// Judge if the `XArray` is marked with the input `mark`.
     pub fn is_marked(&self, mark: M) -> bool {
-        self.marks[mark.index()]
+        self.marks[mark.into().index()]
     }
 
     /// Return a reference to the head entry, and later will not modify the XNode pointed to by the `head`.
@@ -94,19 +102,17 @@ impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
         &self.head
     }
 
-    /// Return a reference to the head entry, and later may modify the XNode pointed to by the `head`.
-    pub(super) fn head_mut(&mut self, is_exclusive: bool) -> &XEntry<I, L> {
-        if is_exclusive {
-            // When a modification to the head is needed, it first checks whether the head is shared with other XArrays.
-            // If it is, then it performs COW by allocating a new head and using it,
-            // to prevent the modification from affecting the read or write operations on other XArrays.
-            if let Some(new_head) = self.copy_if_shared(&self.head) {
-                self.set_head(new_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);
         }
-        &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()
@@ -124,7 +130,7 @@ impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
     /// 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(&self, index: u64) -> Option<&I> {
-        let mut cursor = self.cursor(index);
+        let cursor = self.cursor(index);
         cursor.load()
     }
 
@@ -135,48 +141,29 @@ impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
         cursor.store(item)
     }
 
-    /// Attempts to load the item and its mark information about input `mark` at the target index within the `XArray`.
-    /// If the target item exists, return it with `Some`, Otherwise, return `None`.
-    pub fn load_with_mark(&self, index: u64, mark: M) -> Option<(&I, bool)> {
-        let mut cursor = self.cursor(index);
-        let entry = cursor.load();
-        let mark = if entry.is_some() {
-            cursor.is_marked(mark)
-        } 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 mut cursor = self.cursor_mut(index);
-        let old_item = cursor.store(item);
-        cursor.set_mark(mark).unwrap();
-        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_mut(true).as_node_mut() {
+        self.ensure_head_exclusive();
+        if let Some(node) = self.head().as_node_mut() {
             handle_list.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;
-            let node_mark = node.mark(mark.index());
+            let node_mark = node.mark(mark_index);
             while (offset as usize) < SLOT_SIZE {
                 if node_mark.is_marked(offset) {
-                    let entry = node.ref_node_entry(true, 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.clear_mark(mark_index);
         }
     }
 
@@ -188,26 +175,25 @@ impl<I: ItemEntry, L: XLock, M: ValidMark> XArray<I, L, M> {
     }
 
     /// Create an `Cursor` to perform read related operations on the `XArray`.
-    pub fn cursor<'a>(&'a self, index: u64) -> Cursor<'a, I, L, M> {
+    pub fn cursor(&self, index: u64) -> Cursor<'_, I, L, M> {
         Cursor::new(self, index)
     }
 
     /// Create an `CursorMut` to perform read and write operations on the `XArray`.
-    pub fn cursor_mut<'a>(&'a mut self, index: u64) -> CursorMut<'a, I, L, M> {
+    pub fn cursor_mut(&mut self, index: u64) -> CursorMut<'_, I, L, M> {
         CursorMut::new(self, index)
     }
 
-    pub fn range<'a>(&'a self, range: core::ops::Range<u64>) -> Range<'a, I, L, M> {
+    /// 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> {
         let cursor = Cursor::new(self, range.start);
-        Range {
-            cursor,
-            end: range.end,
-        }
+        Range::new(cursor, range.end)
     }
 }
 
-impl<I: ItemEntry + Clone, L: XLock, M: ValidMark> Clone for XArray<I, L, M> {
-    /// Clone with cow mechanism.
+impl<I: ItemEntry + Clone, L: XLock, M: Into<XMark>> Clone for XArray<I, L, M> {
+    /// Clone with COW mechanism.
     fn clone(&self) -> Self {
         let cloned_head = self.head.clone();
         Self {
@@ -217,64 +203,3 @@ impl<I: ItemEntry + Clone, L: XLock, M: ValidMark> Clone for XArray<I, L, M> {
         }
     }
 }
-
-pub trait ValidLock<T>: Sized {
-    type Target<'a>: Deref<Target = T> + DerefMut<Target = T>
-    where
-        Self: 'a;
-
-    fn new(inner: T) -> Self;
-
-    fn lock(&self) -> Self::Target<'_>;
-}
-
-pub trait XLock {
-    type Lock<T>: ValidLock<T>;
-
-    fn new<T>(inner: T) -> Self::Lock<T> {
-        Self::Lock::<T>::new(inner)
-    }
-}
-
-#[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>;
-        }
-    };
-}
-
-pub struct Range<'a, I, L, M>
-where
-    I: ItemEntry,
-    L: XLock,
-    M: ValidMark,
-{
-    cursor: Cursor<'a, I, L, M>,
-    end: u64,
-}
-
-impl<'a, I: ItemEntry, L: XLock, M: ValidMark> core::iter::Iterator for Range<'a, I, L, M> {
-    type Item = (u64, &'a I);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            if self.cursor.index() >= self.end {
-                return None;
-            }
-
-            let item = self.cursor.load();
-            if item.is_none() {
-                self.cursor.next();
-                continue;
-            }
-
-            let res = item.map(|item| (self.cursor.index(), item));
-            self.cursor.next();
-            return res;
-        }
-    }
-}