automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/op_set2/op_set/elems.rs

@@ -0,0 +1,43 @@
+use crate::{
+    marks::{MarkSet, MarkStateMachine},
+    types::Clock,
+};
+
+use super::{Op, OpIter, OpQueryTerm, OpType};
+
+use std::fmt::Debug;
+use std::sync::Arc;
+
+#[derive(Clone, Debug)]
+pub(crate) struct ElemIter<'a, I: Iterator<Item = Op<'a>> + Clone> {
+    iter: I,
+    current: usize,
+    last: Option<Range<usize>>,
+}
+
+impl<'a, I: Iterator<Item = Op<'a>> + Clone> ElemIter<'a, I> {
+    pub(crate) fn new(iter: I) -> Self {
+        Self { iter, start: 0, end: 0 }
+    }
+}
+
+impl<'a, I: Iterator<Item = Op<'a>> + Clone> Iterator for ElemIter<'a, I> {
+    type Item = Op<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(op) = self.iter.next() {
+            return Some(op);
+        }
+        None
+    }
+}
+
+impl<'a, I: OpQueryTerm<'a> + Clone> OpQueryTerm<'a> for ElemIter<'a, I> {
+    fn get_opiter(&self) -> &OpIter<'a> {
+        self.iter.get_opiter()
+    }
+
+    fn get_marks(&self) -> Option<&Arc<MarkSet>> {
+        self.iter.get_marks()
+    }
+}

data/vendor/automerge-rust/automerge/src/op_set2/op_set/found_op.rs

@@ -0,0 +1,60 @@
+use crate::types::Clock;
+
+use super::{Action, KeyRef, Op, OpQueryTerm, OpsFound};
+
+use std::fmt::Debug;
+
+#[derive(Clone, Debug)]
+pub(crate) struct OpsFoundIter<'a, I: Iterator<Item = Op<'a>>> {
+    iter: I,
+    start_pos: usize,
+    clock: Option<Clock>,
+    last_key: Option<KeyRef<'a>>,
+    found: Option<OpsFound<'a>>,
+}
+
+impl<'a, I: Iterator<Item = Op<'a>>> OpsFoundIter<'a, I> {
+    pub(crate) fn new(iter: I, clock: Option<Clock>) -> Self {
+        Self {
+            iter,
+            clock,
+            start_pos: 0,
+            found: None,
+            last_key: None,
+        }
+    }
+}
+
+impl<'a, I: OpQueryTerm<'a>> Iterator for OpsFoundIter<'a, I> {
+    type Item = OpsFound<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut result = None;
+        for mut op in self.iter.by_ref() {
+            let key = op.elemid_or_key();
+            if Some(&key) != self.last_key.as_ref() {
+                result = self.found.take();
+                self.last_key = Some(key);
+                self.found = Some(OpsFound::default());
+                self.start_pos = op.pos;
+            }
+            if let Some(found) = &mut self.found {
+                found.end_pos = op.pos + 1;
+                found.range = self.start_pos..(op.pos + 1);
+                if op.action != Action::Increment && op.scope_to_clock(self.clock.as_ref()) {
+                    found.ops.push(op);
+                }
+            }
+            match &result {
+                Some(f) if !f.ops.is_empty() => return result,
+                _ => (),
+            }
+        }
+        let found = self.found.take()?;
+        if found.ops.is_empty() {
+            None
+        } else {
+            Some(found)
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/op_set2/op_set/index.rs

@@ -0,0 +1,197 @@
+use crate::op_set2::op_set::{MarkIndexBuilder, MarkIndexColumn};
+use crate::op_set2::{ChangeOp, Op, OpBuilder, OpSet};
+use crate::types::{ObjId, ObjType, OpId, SequenceType, TextEncoding};
+use hexane::{BooleanCursor, ColumnData, IntCursor, UIntCursor};
+use std::collections::HashMap;
+
+// TODO : this could be faster and use less memory if
+// hexane::Encoder was used here instead of Vec<>
+
+pub(crate) struct IndexBuilder {
+    counters: HashMap<OpId, Vec<(usize, usize)>>,
+    succ: Vec<u32>,
+    top: Vec<bool>,
+    widths: Vec<u64>,
+    incs: Vec<Option<i64>>,
+    marks: Vec<Option<MarkIndexBuilder>>,
+    obj_info: ObjIndex,
+    last_flush: usize,
+    text_encoding: TextEncoding,
+}
+
+#[derive(Debug, Default, Clone)]
+pub(crate) struct ObjIndex(pub(crate) HashMap<OpId, ObjInfo>);
+
+impl ObjIndex {
+    pub(crate) fn object_type(&self, obj: &ObjId) -> Option<ObjType> {
+        if obj.is_root() {
+            Some(ObjType::Map)
+        } else {
+            self.0.get(&obj.0).map(|p| p.obj_type)
+        }
+    }
+
+    pub(crate) fn object_parent(&self, obj: &ObjId) -> Option<ObjId> {
+        if obj.is_root() {
+            None
+        } else {
+            self.0.get(&obj.0).map(|p| p.parent)
+        }
+    }
+
+    pub(crate) fn insert(&mut self, id: OpId, obj_info: ObjInfo) {
+        self.0.insert(id, obj_info);
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct ObjInfo {
+    pub(crate) parent: ObjId,
+    pub(crate) obj_type: ObjType,
+}
+
+impl ObjInfo {
+    pub(crate) fn with_new_actor(self, idx: usize) -> Self {
+        Self {
+            parent: self.parent.with_new_actor(idx),
+            obj_type: self.obj_type,
+        }
+    }
+
+    pub(crate) fn without_actor(self, idx: usize) -> Option<Self> {
+        Some(Self {
+            parent: self.parent.without_actor(idx)?,
+            obj_type: self.obj_type,
+        })
+    }
+}
+
+impl Op<'_> {
+    pub(crate) fn obj_info(&self) -> Option<ObjInfo> {
+        let obj_type = ObjType::try_from(self.action).ok()?;
+        let parent = self.obj;
+        Some(ObjInfo { parent, obj_type })
+    }
+}
+
+impl ChangeOp {
+    pub(crate) fn obj_info(&self) -> Option<ObjInfo> {
+        self.bld.obj_info()
+    }
+}
+
+impl OpBuilder<'_> {
+    pub(crate) fn obj_info(&self) -> Option<ObjInfo> {
+        let obj_type = ObjType::try_from(self.action).ok()?;
+        let parent = self.obj;
+        Some(ObjInfo { parent, obj_type })
+    }
+}
+
+pub(crate) struct Indexes {
+    pub(crate) text: ColumnData<UIntCursor>,
+    pub(crate) top: ColumnData<BooleanCursor>,
+    pub(crate) visible: ColumnData<BooleanCursor>,
+    pub(crate) inc: ColumnData<IntCursor>,
+    pub(crate) mark: MarkIndexColumn,
+    pub(crate) obj_info: ObjIndex,
+}
+
+impl IndexBuilder {
+    pub(crate) fn new(op_set: &OpSet, encoding: TextEncoding) -> Self {
+        Self {
+            counters: HashMap::new(),
+            succ: Vec::with_capacity(op_set.len()),
+            top: Vec::with_capacity(op_set.len()),
+            widths: Vec::with_capacity(op_set.len()),
+            incs: Vec::with_capacity(op_set.sub_len()),
+            marks: Vec::with_capacity(op_set.len()),
+            obj_info: ObjIndex::default(),
+            last_flush: 0,
+            text_encoding: encoding,
+        }
+    }
+
+    pub(crate) fn flush(&mut self) {
+        let len = self.succ.len();
+        for (delta, succ) in self.succ[self.last_flush..].iter().rev().enumerate() {
+            if *succ == 0 {
+                self.top[len - delta - 1] = true;
+                break;
+            }
+        }
+        self.last_flush = len;
+    }
+    pub(crate) fn process_op(&mut self, op: &Op<'_>) {
+        self.marks.push(op.mark_index());
+
+        self.succ.push(vis_num(op));
+        self.top.push(false);
+
+        self.widths
+            .push(op.width(SequenceType::Text, self.text_encoding) as u64);
+
+        let count = self.counters.remove(&op.id);
+
+        if let Some(i) = op.get_increment_value() {
+            for (succ_idx, op_idx) in count.into_iter().flatten() {
+                self.incs[succ_idx] = Some(i);
+                self.succ[op_idx] -= 1;
+            }
+        }
+
+        if let Some(obj_info) = op.obj_info() {
+            self.obj_info.insert(op.id, obj_info);
+        }
+    }
+
+    pub(crate) fn process_succ(&mut self, op_is_counter: bool, id: OpId) {
+        if op_is_counter {
+            self.counters
+                .entry(id)
+                .or_default()
+                .push((self.incs.len(), self.succ.len() - 1));
+        }
+        self.incs.push(None); // will update later
+    }
+
+    pub(crate) fn finish(mut self) -> Indexes {
+        self.flush();
+
+        let text = self
+            .widths
+            .iter()
+            .zip(self.succ.iter())
+            .map(|(w, t)| if *t == 0 { Some(*w) } else { None })
+            .collect();
+
+        let visible = self.succ.iter().map(|&n| n == 0).collect();
+
+        let top = self.top.iter().collect();
+
+        let mut inc = ColumnData::new();
+        inc.splice(0, 0, self.incs);
+
+        let mut mark = MarkIndexColumn::new();
+        mark.splice(0, 0, self.marks);
+
+        let obj_info = self.obj_info;
+
+        Indexes {
+            text,
+            top,
+            visible,
+            inc,
+            mark,
+            obj_info,
+        }
+    }
+}
+
+fn vis_num(op: &Op<'_>) -> u32 {
+    if op.is_inc() {
+        u32::MAX
+    } else {
+        op.succ().len() as u32
+    }
+}

data/vendor/automerge-rust/automerge/src/op_set2/op_set/insert.rs

@@ -0,0 +1,179 @@
+use crate::{
+    error::AutomergeError,
+    marks::{MarkSet, RichTextQueryState},
+    types::{Clock, ElemId, OpId, SequenceType},
+    TextEncoding,
+};
+
+use super::{Action, Op, OpIter, OpType, QueryNth};
+
+use std::fmt::Debug;
+
+#[derive(Clone, Debug)]
+pub(crate) struct InsertQuery<'a> {
+    iter: OpIter<'a>,
+    marks: RichTextQueryState<'a>,
+    seq_type: SequenceType,
+    text_encoding: TextEncoding,
+    clock: Option<Clock>,
+    candidates: Vec<Loc>,
+    last_visible_cursor: Option<ElemId>,
+    target: usize,
+}
+
+impl<'a> InsertQuery<'a> {
+    pub(crate) fn new(
+        iter: OpIter<'a>,
+        target: usize,
+        seq_type: SequenceType,
+        text_encoding: TextEncoding,
+        clock: Option<Clock>,
+        marks: RichTextQueryState<'a>,
+    ) -> Self {
+        //let marks = RichTextQueryState::default();
+        let mut candidates = vec![];
+        let last_visible_cursor = None;
+        if target == 0 {
+            candidates.push(Loc::new(iter.pos(), ElemId::head()));
+        };
+        Self {
+            iter,
+            marks,
+            seq_type,
+            text_encoding,
+            target,
+            candidates,
+            clock,
+            last_visible_cursor,
+        }
+    }
+
+    fn identify_valid_insertion_spot(&mut self, op: &Op<'a>, cursor: ElemId) {
+        // first insert we see after list_state.done()
+        if op.insert && self.candidates.is_empty() {
+            if let Some(cursor) = self.last_visible_cursor {
+                self.candidates.push(Loc::new(op.pos, cursor))
+            }
+        }
+
+        // sticky marks
+        if !self.candidates.is_empty() {
+            // if we find a begin/end pair - ignore them
+            if let OpType::MarkEnd(_) = op.action() {
+                if let Some(pos) = self.candidates.iter().position(|loc| loc.matches(op)) {
+                    // mark points between begin and end are invalid
+                    self.candidates.truncate(pos);
+                    return;
+                }
+            }
+            if matches!(
+                op.action(),
+                OpType::MarkBegin(true, _) | OpType::MarkEnd(false)
+            ) {
+                self.candidates.push(Loc::mark(op.pos + 1, cursor, op.id));
+            }
+        }
+    }
+
+    // this query is particularly tricky b/c
+    // we care about marks, visible ops, and non-visible ops all at once
+
+    pub(crate) fn resolve(&mut self, mut index: usize) -> Result<QueryNth, AutomergeError> {
+        let mut last_width = None;
+        let mut done = index >= self.target;
+        let mut pos = self.iter.pos();
+        let mut post_marks = vec![];
+        while let Some(mut op) = self.iter.next() {
+            let op_pos = op.pos;
+            if op.is_inc() {
+                continue;
+            }
+            let visible = op.scope_to_clock(self.clock.as_ref());
+            if op.insert {
+                // this is the one place where we need non-visible ops
+                if let Some(last) = last_width.take() {
+                    index += last;
+                    done = index >= self.target;
+                }
+            }
+            let cursor = op.cursor().unwrap();
+            if done {
+                self.identify_valid_insertion_spot(&op, cursor);
+                if visible {
+                    if op.action == Action::Mark {
+                        post_marks.push(op);
+                    } else if !self.candidates.is_empty() {
+                        break;
+                    }
+                }
+            } else if visible {
+                if !op.is_mark() {
+                    self.last_visible_cursor = Some(cursor);
+                    last_width = Some(op.width(self.seq_type, self.text_encoding));
+                }
+                self.marks.process(op, None);
+            }
+            pos = op_pos;
+        }
+
+        if let Some(last) = last_width.take() {
+            index += last;
+            done = index >= self.target;
+        }
+
+        if !done {
+            Err(AutomergeError::InvalidIndex(self.target))
+        } else if let Some(loc) = self.candidates.pop() {
+            // process all the marks before the final pos
+            for op in post_marks {
+                if op.pos < loc.pos {
+                    self.marks.process(op, None);
+                }
+            }
+            Ok(QueryNth {
+                pos: loc.pos,
+                marks: MarkSet::from_query_state(&self.marks),
+                elemid: loc.cursor,
+                index,
+            })
+        } else if let Some(cursor) = self.last_visible_cursor {
+            Ok(QueryNth {
+                pos: pos + 1,
+                marks: MarkSet::from_query_state(&self.marks),
+                elemid: cursor,
+                index,
+            })
+        } else {
+            Err(AutomergeError::InvalidIndex(self.target))
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Loc {
+    pub(crate) cursor: ElemId,
+    pub(crate) pos: usize,
+    id: Option<OpId>,
+}
+
+impl Loc {
+    fn new(pos: usize, cursor: ElemId) -> Self {
+        Loc {
+            cursor,
+            pos,
+            id: None,
+        }
+    }
+
+    fn mark(pos: usize, cursor: ElemId, id: OpId) -> Self {
+        Loc {
+            cursor,
+            pos,
+            id: Some(id),
+        }
+    }
+
+    fn matches(&self, op: &Op<'_>) -> bool {
+        self.id == Some(op.id.prev())
+    }
+}