feat: impl crdt types

Author: forehalo

libs/jwst-codec/src/doc/codec/content.rs

@@ -171,15 +171,18 @@ impl Content {
         }
     }
 
-    pub fn split(&self, diff: u64) -> JwstCodecResult<(Self, Self)> {
+    pub fn countable(&self) -> bool {
+        !matches!(self, Content::Format { .. } | Content::Deleted(_))
+    }
+
+    pub fn split(&mut self, diff: u64) -> JwstCodecResult<Self> {
         // TODO: implement split for other types
         match self {
             Self::String(str) => {
                 let (left, right) = str.split_at(diff as usize);
-                Ok((
-                    Self::String(left.to_string()),
-                    Self::String(right.to_string()),
-                ))
+                let right = right.to_string();
+                *str = left.to_string();
+                Ok(Self::String(right))
             }
             _ => Err(JwstCodecError::ContentSplitNotSupport(diff)),
         }

libs/jwst-codec/src/doc/codec/delete.rs

@@ -0,0 +1,106 @@
+use crate::doc::common::OrderRange;
+
+use super::*;
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    ops::{Deref, DerefMut, Range},
+};
+
+impl<R: CrdtReader> CrdtRead<R> for Range<u64> {
+    fn read(decoder: &mut R) -> JwstCodecResult<Self> {
+        let clock = decoder.read_var_u64()?;
+        let len = decoder.read_var_u64()?;
+        Ok(clock..clock + len)
+    }
+}
+
+impl<R: CrdtReader> CrdtRead<R> for OrderRange {
+    fn read(decoder: &mut R) -> JwstCodecResult<Self> {
+        let num_of_deletes = decoder.read_var_u64()? as usize;
+        let mut deletes = Vec::with_capacity(num_of_deletes);
+
+        for _ in 0..num_of_deletes {
+            deletes.push(Range::<u64>::read(decoder)?);
+        }
+
+        Ok(OrderRange::Fragment(deletes))
+    }
+}
+
+impl<R: CrdtReader> CrdtRead<R> for DeleteSet {
+    fn read(decoder: &mut R) -> JwstCodecResult<Self> {
+        let num_of_clients = decoder.read_var_u64()? as usize;
+        let mut map = HashMap::with_capacity(num_of_clients);
+
+        for _ in 0..num_of_clients {
+            let client = decoder.read_var_u64()?;
+            let deletes = OrderRange::read(decoder)?;
+            map.insert(client, deletes);
+        }
+
+        Ok(DeleteSet(map))
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct DeleteSet(pub HashMap<Client, OrderRange>);
+
+impl Deref for DeleteSet {
+    type Target = HashMap<Client, OrderRange>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for DeleteSet {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl DeleteSet {
+    pub fn add(&mut self, client: Client, from: Clock, len: Clock) {
+        self.add_range(client, from..from + len);
+    }
+
+    pub fn add_range(&mut self, client: Client, range: Range<u64>) {
+        match self.0.entry(client) {
+            Entry::Occupied(e) => {
+                let r = e.into_mut();
+                if r.is_empty() {
+                    *r = range.into();
+                } else {
+                    r.push(range);
+                }
+            }
+            Entry::Vacant(e) => {
+                e.insert(range.into());
+            }
+        }
+    }
+
+    pub fn batch_push(&mut self, client: Client, ranges: Vec<Range<u64>>) {
+        match self.0.entry(client) {
+            Entry::Occupied(e) => {
+                e.into_mut().extends(ranges);
+            }
+            Entry::Vacant(e) => {
+                e.insert(ranges.into());
+            }
+        }
+    }
+
+    pub fn merge(&mut self, other: Self) {
+        for (client, range) in other.0 {
+            match self.0.entry(client) {
+                Entry::Occupied(e) => {
+                    e.into_mut().merge(range);
+                }
+                Entry::Vacant(e) => {
+                    e.insert(range);
+                }
+            }
+        }
+    }
+}

libs/jwst-codec/src/doc/codec/delete_set.rs

@@ -1,12 +1,13 @@
 use std::{
+    cmp::Ordering,
     hash::Hash,
     ops::{Add, Sub},
 };
 
 pub type Client = u64;
 pub type Clock = u64;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
 pub struct Id {
     pub client: Client,
     pub clock: Clock,
@@ -39,3 +40,18 @@ impl Add<Clock> for Id {
         (self.client, self.clock + rhs).into()
     }
 }
+
+impl PartialOrd for Id {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match self.client.cmp(&other.client) {
+            Ordering::Equal => Some(self.clock.cmp(&other.clock)),
+            _ => None,
+        }
+    }
+}
+
+impl Ord for Id {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.clock.cmp(&other.clock)
+    }
+}

libs/jwst-codec/src/doc/codec/id.rs

@@ -6,13 +6,139 @@ pub enum Parent {
     Id(Id),
 }
 
+#[rustfmt::skip]
+#[allow(dead_code)]
+pub mod item_flags {
+    pub const ITEM_KEEP            : u8 = 0b0000_0001;
+    pub const ITEM_COUNTABLE       : u8 = 0b0000_0010;
+    pub const ITEM_DELETED         : u8 = 0b0000_0100;
+    pub const ITEM_MARKED          : u8 = 0b0000_1000;
+    pub const ITEM_HAS_PARENT_SUB  : u8 = 0b0010_0000;
+    pub const ITEM_HAS_RIGHT_ID    : u8 = 0b0100_0000;
+    pub const ITEM_HAS_LEFT_ID     : u8 = 0b1000_0000;
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ItemFlags(u8);
+
+impl From<u8> for ItemFlags {
+    fn from(flags: u8) -> Self {
+        Self(flags)
+    }
+}
+
+impl ItemFlags {
+    #[inline(always)]
+    pub fn set(&mut self, flag: u8) {
+        self.0 |= flag;
+    }
+
+    #[inline(always)]
+    pub fn clear(&mut self, flag: u8) {
+        self.0 &= !flag;
+    }
+
+    #[inline(always)]
+    pub fn check(&self, flag: u8) -> bool {
+        self.0 & flag == flag
+    }
+
+    #[inline(always)]
+    pub fn not(&self, flag: u8) -> bool {
+        self.0 & flag == 0
+    }
+
+    #[inline(always)]
+    pub fn keep(&self) -> bool {
+        self.check(item_flags::ITEM_KEEP)
+    }
+
+    #[inline(always)]
+    pub fn set_keep(&mut self) {
+        self.set(item_flags::ITEM_KEEP);
+    }
+
+    #[inline(always)]
+    pub fn clear_keep(&mut self) {
+        self.clear(item_flags::ITEM_KEEP);
+    }
+
+    #[inline(always)]
+    pub fn countable(&self) -> bool {
+        self.check(item_flags::ITEM_COUNTABLE)
+    }
+
+    #[inline(always)]
+    pub fn set_countable(&mut self) {
+        self.set(item_flags::ITEM_COUNTABLE);
+    }
+
+    #[inline(always)]
+    pub fn clear_countable(&mut self) {
+        self.clear(item_flags::ITEM_COUNTABLE);
+    }
+
+    #[inline(always)]
+    pub fn deleted(&self) -> bool {
+        self.check(item_flags::ITEM_DELETED)
+    }
+
+    #[inline(always)]
+    pub fn set_deleted(&mut self) {
+        self.set(item_flags::ITEM_DELETED);
+    }
+
+    #[inline(always)]
+    pub fn clear_deleted(&mut self) {
+        self.clear(item_flags::ITEM_DELETED);
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct Item {
     pub left_id: Option<Id>,
     pub right_id: Option<Id>,
     pub parent: Option<Parent>,
     pub parent_sub: Option<String>,
     pub content: Content,
+    pub flags: ItemFlags,
+}
+
+impl Default for Item {
+    fn default() -> Self {
+        Self {
+            left_id: None,
+            right_id: None,
+            parent: None,
+            parent_sub: None,
+            content: Content::String("".into()),
+            flags: ItemFlags::from(item_flags::ITEM_COUNTABLE),
+        }
+    }
+}
+
+impl Item {
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn len(&self) -> u64 {
+        self.content.clock_len()
+    }
+
+    pub fn deleted(&self) -> bool {
+        self.flags.deleted()
+    }
+
+    pub fn delete(&mut self) {
+        if self.deleted() {
+            return;
+        }
+
+        // self.content.delete();
+
+        self.flags.deleted();
+    }
 }
 
 impl Item {
@@ -21,14 +147,15 @@ impl Item {
         info: u8,
         first_5_bit: u8,
     ) -> JwstCodecResult<Self> {
-        let has_left_id = info & 0b1000_0000 == 0b1000_0000;
-        let has_right_id = info & 0b0100_0000 == 0b0100_0000;
-        let has_parent_sub = info & 0b0010_0000 == 0b0010_0000;
-        let has_not_parent_info = info & 0b1100_0000 == 0;
+        let flags: ItemFlags = info.into();
+        let has_left_id = flags.check(item_flags::ITEM_HAS_LEFT_ID);
+        let has_right_id = flags.check(item_flags::ITEM_HAS_RIGHT_ID);
+        let has_parent_sub = flags.check(item_flags::ITEM_HAS_PARENT_SUB);
+        let has_not_parent_info = !(has_left_id || has_right_id);
 
         // NOTE: read order must keep the same as the order in yjs
         // TODO: this data structure design will break the cpu OOE, need to be optimized
-        let item = Self {
+        let mut item = Self {
             left_id: if has_left_id {
                 Some(decoder.read_item_id()?)
             } else {
@@ -62,8 +189,13 @@ impl Item {
                 debug_assert_ne!(first_5_bit, 10);
                 Content::read(decoder, first_5_bit)?
             },
+            flags: ItemFlags::from(0),
         };
 
+        if item.content.countable() {
+            item.flags.set_countable();
+        }
+
         Ok(item)
     }
 
@@ -72,16 +204,13 @@ impl Item {
             // write info
             let mut info = self.content.get_info();
             if self.left_id.is_some() {
-                info |= 0b1000_0000;
+                info |= item_flags::ITEM_HAS_LEFT_ID;
             }
             if self.right_id.is_some() {
-                info |= 0b0100_0000;
-            }
-            if self.parent.is_some() || self.parent_sub.is_some() {
-                info |= 0b0010_0000;
+                info |= item_flags::ITEM_HAS_RIGHT_ID;
             }
-            if self.parent.is_none() && self.parent_sub.is_none() {
-                info |= 0b0001_0000;
+            if self.parent_sub.is_some() {
+                info |= item_flags::ITEM_HAS_PARENT_SUB;
             }
             encoder.write_info(info)?;
         }