refactor: rename len method in old rlevec

crates/loro-core/src/container/text/tracker/content_map.rs

@@ -134,7 +134,7 @@ impl ContentMap {
             }
         }
 
-        assert_eq!(len, ans.len());
+        assert_eq!(len, ans.atom_len());
         ans
     }
 

crates/loro-core/src/container/text/tracker/cursor_map.rs

@@ -156,7 +156,7 @@ impl HasLength for Marker {
     fn content_len(&self) -> usize {
         match self {
             Marker::Insert { ptr: _, len } => *len,
-            Marker::Delete(span) => span.len(),
+            Marker::Delete(span) => span.atom_len(),
         }
     }
 }
@@ -258,9 +258,9 @@ impl CursorMap {
                     }
                 }
                 Marker::Delete(del) => {
-                    if span.intersect(&id.to_span(del.len())) {
+                    if span.intersect(&id.to_span(del.atom_len())) {
                         let from = (span.counter.min() - id.counter).max(0);
-                        let to = (span.counter.end() - id.counter).min(del.len() as Counter);
+                        let to = (span.counter.end() - id.counter).min(del.atom_len() as Counter);
                         if to - from > 0 {
                             deletes.push((id.inc(from), del.slice(from as usize, to as usize)));
                         }
@@ -271,7 +271,7 @@ impl CursorMap {
 
         if cfg!(test) {
             let insert_len: usize = inserts.iter().map(|x| x.1.len).sum();
-            let del_len: usize = deletes.iter().map(|x| x.1.len()).sum();
+            let del_len: usize = deletes.iter().map(|x| x.1.atom_len()).sum();
             assert_eq!(insert_len + del_len, span.content_len());
         }
 
@@ -291,7 +291,10 @@ impl CursorMap {
                 Marker::Delete(del) => {
                     return Some(FirstCursorResult::Del(
                         span.id_start(),
-                        del.slice((span.id_start().counter - id.counter) as usize, del.len()),
+                        del.slice(
+                            (span.id_start().counter - id.counter) as usize,
+                            del.atom_len(),
+                        ),
                     ))
                 }
             }

crates/loro-core/src/container/text/tracker/effects_iter.rs

@@ -117,8 +117,10 @@ impl<'a> Iterator for EffectIter<'a> {
                         }
                         FirstCursorResult::Del(id, del) => {
                             assert!(current.contains_id(id));
-                            assert!(current.contains_id(id.inc(del.len() as Counter - 1)));
-                            current.counter.set_start(id.counter + del.len() as Counter);
+                            assert!(current.contains_id(id.inc(del.atom_len() as Counter - 1)));
+                            current
+                                .counter
+                                .set_start(id.counter + del.atom_len() as Counter);
                             self.current_delete_targets = Some(del.iter().cloned().collect());
                         }
                     }

crates/loro-core/src/log_store.rs

@@ -301,7 +301,7 @@ impl LogStore {
     pub fn contains(&self, id: ID) -> bool {
         self.changes
             .get(&id.client_id)
-            .map_or(0, |changes| changes.len())
+            .map_or(0, |changes| changes.atom_len())
             > id.counter as usize
     }
 
@@ -309,7 +309,7 @@ impl LogStore {
     fn get_next_counter(&self, client_id: ClientID) -> Counter {
         self.changes
             .get(&client_id)
-            .map(|changes| changes.len())
+            .map(|changes| changes.atom_len())
             .unwrap_or(0) as Counter
     }
 

crates/loro-core/src/op/op_content.rs

@@ -27,8 +27,8 @@ impl HasLength for OpContent {
     fn content_len(&self) -> usize {
         match self {
             OpContent::Normal { content, .. } => content.content_len(),
-            OpContent::Undo { target, .. } => target.len(),
-            OpContent::Redo { target, .. } => target.len(),
+            OpContent::Undo { target, .. } => target.atom_len(),
+            OpContent::Redo { target, .. } => target.atom_len(),
         }
     }
 }

crates/loro-core/src/span.rs

@@ -313,19 +313,19 @@ mod test_id_span {
             counter: CounterSpan::new(0, 2),
         });
         assert_eq!(id_span_vec.merged_len(), 1);
-        assert_eq!(id_span_vec.len(), 2);
+        assert_eq!(id_span_vec.atom_len(), 2);
         id_span_vec.push(IdSpan {
             client_id: 0,
             counter: CounterSpan::new(2, 4),
         });
         assert_eq!(id_span_vec.merged_len(), 1);
-        assert_eq!(id_span_vec.len(), 4);
+        assert_eq!(id_span_vec.atom_len(), 4);
         id_span_vec.push(IdSpan {
             client_id: 2,
             counter: CounterSpan::new(2, 4),
         });
         assert_eq!(id_span_vec.merged_len(), 2);
-        assert_eq!(id_span_vec.len(), 6);
+        assert_eq!(id_span_vec.atom_len(), 6);
     }
 
     #[test]

crates/loro-framework/src/raw_store.rs

@@ -3,7 +3,7 @@ use loro_core::{
     id::{ClientID, Counter},
     version::VersionVector,
 };
-use rle::RleVecWithIndex;
+use rle::{HasLength, RleVecWithIndex};
 
 use crate::raw_change::{ChangeData, ChangeHash};
 
@@ -77,7 +77,7 @@ impl RawStore {
     pub fn version_vector(&self) -> VersionVector {
         let mut version_vector = VersionVector::new();
         for (client_id, changes) in &self.changes {
-            version_vector.insert(*client_id, changes.len() as Counter);
+            version_vector.insert(*client_id, changes.atom_len() as Counter);
         }
 
         version_vector

crates/rle/src/rle_vec_old.rs

@@ -21,7 +21,7 @@ use crate::{HasLength, Mergable, Slice, Sliceable};
 #[derive(Debug, Clone)]
 pub struct RleVecWithIndex<T, Cfg = ()> {
     vec: Vec<T>,
-    _len: usize,
+    atom_len: usize,
     index: Vec<usize>,
     cfg: Cfg,
 }
@@ -44,37 +44,32 @@ impl<T: Eq + PartialEq> Eq for RleVecWithIndex<T> {}
 impl<T: Mergable<Cfg> + HasLength, Cfg> RleVecWithIndex<T, Cfg> {
     /// push a new element to the end of the array. It may be merged with last element.
     pub fn push(&mut self, value: T) {
-        self._len += value.content_len();
+        self.atom_len += value.content_len();
         if self.vec.is_empty() {
             self.vec.push(value);
             self.index.push(0);
-            self.index.push(self._len);
+            self.index.push(self.atom_len);
             return;
         }
 
         let last = self.vec.last_mut().unwrap();
         if last.is_mergable(&value, &self.cfg) {
             last.merge(&value, &self.cfg);
-            *self.index.last_mut().unwrap() = self._len;
+            *self.index.last_mut().unwrap() = self.atom_len;
             return;
         }
         self.vec.push(value);
-        self.index.push(self._len);
+        self.index.push(self.atom_len);
     }
 
     pub fn is_empty(&self) -> bool {
         self.vec.is_empty()
     }
 
-    /// number of atom elements in the array.
-    pub fn len(&self) -> usize {
-        self._len
-    }
-
     /// get the element at the given atom index.
     /// return: (element, merged_index, offset)
     pub fn get(&self, index: usize) -> Option<SearchResult<'_, T, usize>> {
-        if index > self.len() {
+        if index > self.atom_len {
             return None;
         }
 
@@ -133,7 +128,11 @@ impl<T: Mergable<Cfg> + HasLength, Cfg> RleVecWithIndex<T, Cfg> {
         }
 
         let from_result = from_result.unwrap();
-        let to_result = if to == self.len() { None } else { self.get(to) };
+        let to_result = if to == self.atom_len {
+            None
+        } else {
+            self.get(to)
+        };
         if let Some(to_result) = to_result {
             SliceIterator {
                 vec: &self.vec,
@@ -162,7 +161,7 @@ impl<T, Conf: Default> RleVecWithIndex<T, Conf> {
     pub fn new() -> Self {
         RleVecWithIndex {
             vec: Vec::new(),
-            _len: 0,
+            atom_len: 0,
             index: Vec::new(),
             cfg: Default::default(),
         }
@@ -193,7 +192,7 @@ impl<T, Conf> RleVecWithIndex<T, Conf> {
     pub fn new_cfg(cfg: Conf) -> Self {
         RleVecWithIndex {
             vec: Vec::new(),
-            _len: 0,
+            atom_len: 0,
             index: Vec::new(),
             cfg,
         }
@@ -321,13 +320,17 @@ impl<T: Mergable + HasLength + Sliceable + Clone> Sliceable for RleVecWithIndex<
     }
 }
 
-impl<T> HasLength for RleVecWithIndex<T> {
+impl<T, Cfg> HasLength for RleVecWithIndex<T, Cfg> {
     fn content_len(&self) -> usize {
-        self._len
+        self.atom_len
+    }
+
+    fn atom_len(&self) -> usize {
+        self.atom_len
     }
 }
 
-impl<T> Deref for RleVecWithIndex<T> {
+impl<T, Cfg> Deref for RleVecWithIndex<T, Cfg> {
     type Target = [T];
 
     fn deref(&self) -> &Self::Target {