1mod anchor;
2pub mod locator;
3#[cfg(any(test, feature = "test-support"))]
4pub mod network;
5pub mod operation_queue;
6mod patch;
7mod point;
8mod point_utf16;
9#[cfg(any(test, feature = "test-support"))]
10pub mod random_char_iter;
11pub mod rope;
12mod selection;
13pub mod subscription;
14#[cfg(test)]
15mod tests;
16
17pub use anchor::*;
18use anyhow::Result;
19use clock::ReplicaId;
20use collections::{HashMap, HashSet};
21use locator::Locator;
22use operation_queue::OperationQueue;
23pub use patch::Patch;
24pub use point::*;
25pub use point_utf16::*;
26use postage::{barrier, oneshot, prelude::*};
27#[cfg(any(test, feature = "test-support"))]
28pub use random_char_iter::*;
29use rope::TextDimension;
30pub use rope::{Chunks, Rope, TextSummary};
31pub use selection::*;
32use std::{
33 cmp::{self, Ordering},
34 future::Future,
35 iter::Iterator,
36 ops::{self, Deref, Range, Sub},
37 str,
38 sync::Arc,
39 time::{Duration, Instant},
40};
41pub use subscription::*;
42pub use sum_tree::Bias;
43use sum_tree::{FilterCursor, SumTree};
44
45pub type TransactionId = clock::Local;
46
47pub struct Buffer {
48 snapshot: BufferSnapshot,
49 history: History,
50 deferred_ops: OperationQueue<Operation>,
51 deferred_replicas: HashSet<ReplicaId>,
52 replica_id: ReplicaId,
53 local_clock: clock::Local,
54 pub lamport_clock: clock::Lamport,
55 subscriptions: Topic,
56 edit_id_resolvers: HashMap<clock::Local, Vec<oneshot::Sender<()>>>,
57 version_barriers: Vec<(clock::Global, barrier::Sender)>,
58}
59
60#[derive(Clone, Debug)]
61pub struct BufferSnapshot {
62 replica_id: ReplicaId,
63 remote_id: u64,
64 visible_text: Rope,
65 deleted_text: Rope,
66 undo_map: UndoMap,
67 fragments: SumTree<Fragment>,
68 insertions: SumTree<InsertionFragment>,
69 pub version: clock::Global,
70}
71
72#[derive(Clone, Debug)]
73pub struct HistoryEntry {
74 transaction: Transaction,
75 first_edit_at: Instant,
76 last_edit_at: Instant,
77 suppress_grouping: bool,
78}
79
80#[derive(Clone, Debug)]
81pub struct Transaction {
82 pub id: TransactionId,
83 pub edit_ids: Vec<clock::Local>,
84 pub start: clock::Global,
85 pub end: clock::Global,
86 pub ranges: Vec<Range<FullOffset>>,
87}
88
89impl HistoryEntry {
90 pub fn transaction_id(&self) -> TransactionId {
91 self.transaction.id
92 }
93
94 fn push_edit(&mut self, edit_operation: &EditOperation) {
95 self.transaction
96 .edit_ids
97 .push(edit_operation.timestamp.local());
98 self.transaction
99 .end
100 .observe(edit_operation.timestamp.local());
101
102 let mut edits = edit_operation
103 .ranges
104 .iter()
105 .zip(edit_operation.new_text.iter())
106 .peekable();
107 let mut new_ranges = Vec::new();
108 let mut delta = 0;
109
110 for mut self_range in self.transaction.ranges.iter().cloned() {
111 self_range.start += delta;
112 self_range.end += delta;
113
114 while let Some((other_range, new_text)) = edits.peek() {
115 let insertion_len = new_text.len();
116 let mut other_range = (*other_range).clone();
117 other_range.start += delta;
118 other_range.end += delta;
119
120 if other_range.start <= self_range.end {
121 edits.next().unwrap();
122 delta += insertion_len;
123
124 if other_range.end < self_range.start {
125 new_ranges.push(other_range.start..other_range.end + insertion_len);
126 self_range.start += insertion_len;
127 self_range.end += insertion_len;
128 } else {
129 self_range.start = cmp::min(self_range.start, other_range.start);
130 self_range.end = cmp::max(self_range.end, other_range.end) + insertion_len;
131 }
132 } else {
133 break;
134 }
135 }
136
137 new_ranges.push(self_range);
138 }
139
140 for (other_range, new_text) in edits {
141 let insertion_len = new_text.len();
142 new_ranges.push(other_range.start + delta..other_range.end + delta + insertion_len);
143 delta += insertion_len;
144 }
145
146 self.transaction.ranges = new_ranges;
147 }
148}
149
150#[derive(Clone)]
151pub struct History {
152 // TODO: Turn this into a String or Rope, maybe.
153 pub base_text: Arc<str>,
154 operations: HashMap<clock::Local, Operation>,
155 undo_stack: Vec<HistoryEntry>,
156 redo_stack: Vec<HistoryEntry>,
157 transaction_depth: usize,
158 group_interval: Duration,
159}
160
161impl History {
162 pub fn new(base_text: Arc<str>) -> Self {
163 Self {
164 base_text,
165 operations: Default::default(),
166 undo_stack: Vec::new(),
167 redo_stack: Vec::new(),
168 transaction_depth: 0,
169 group_interval: Duration::from_millis(300),
170 }
171 }
172
173 fn push(&mut self, op: Operation) {
174 self.operations.insert(op.local_timestamp(), op);
175 }
176
177 fn start_transaction(
178 &mut self,
179 start: clock::Global,
180 now: Instant,
181 local_clock: &mut clock::Local,
182 ) -> Option<TransactionId> {
183 self.transaction_depth += 1;
184 if self.transaction_depth == 1 {
185 let id = local_clock.tick();
186 self.undo_stack.push(HistoryEntry {
187 transaction: Transaction {
188 id,
189 start: start.clone(),
190 end: start,
191 edit_ids: Default::default(),
192 ranges: Default::default(),
193 },
194 first_edit_at: now,
195 last_edit_at: now,
196 suppress_grouping: false,
197 });
198 Some(id)
199 } else {
200 None
201 }
202 }
203
204 fn end_transaction(&mut self, now: Instant) -> Option<&HistoryEntry> {
205 assert_ne!(self.transaction_depth, 0);
206 self.transaction_depth -= 1;
207 if self.transaction_depth == 0 {
208 if self
209 .undo_stack
210 .last()
211 .unwrap()
212 .transaction
213 .ranges
214 .is_empty()
215 {
216 self.undo_stack.pop();
217 None
218 } else {
219 self.redo_stack.clear();
220 let entry = self.undo_stack.last_mut().unwrap();
221 entry.last_edit_at = now;
222 Some(entry)
223 }
224 } else {
225 None
226 }
227 }
228
229 fn group(&mut self) -> Option<TransactionId> {
230 let mut new_len = self.undo_stack.len();
231 let mut entries = self.undo_stack.iter_mut();
232
233 if let Some(mut entry) = entries.next_back() {
234 while let Some(prev_entry) = entries.next_back() {
235 if !prev_entry.suppress_grouping
236 && entry.first_edit_at - prev_entry.last_edit_at <= self.group_interval
237 && entry.transaction.start == prev_entry.transaction.end
238 {
239 entry = prev_entry;
240 new_len -= 1;
241 } else {
242 break;
243 }
244 }
245 }
246
247 let (entries_to_keep, entries_to_merge) = self.undo_stack.split_at_mut(new_len);
248 if let Some(last_entry) = entries_to_keep.last_mut() {
249 for entry in &*entries_to_merge {
250 for edit_id in &entry.transaction.edit_ids {
251 last_entry.push_edit(self.operations[edit_id].as_edit().unwrap());
252 }
253 }
254
255 if let Some(entry) = entries_to_merge.last_mut() {
256 last_entry.last_edit_at = entry.last_edit_at;
257 last_entry.transaction.end = entry.transaction.end.clone();
258 }
259 }
260
261 self.undo_stack.truncate(new_len);
262 self.undo_stack.last().map(|e| e.transaction.id)
263 }
264
265 fn finalize_last_transaction(&mut self) -> Option<&Transaction> {
266 self.undo_stack.last_mut().map(|entry| {
267 entry.suppress_grouping = true;
268 &entry.transaction
269 })
270 }
271
272 fn push_transaction(&mut self, transaction: Transaction, now: Instant) {
273 assert_eq!(self.transaction_depth, 0);
274 self.undo_stack.push(HistoryEntry {
275 transaction,
276 first_edit_at: now,
277 last_edit_at: now,
278 suppress_grouping: false,
279 });
280 self.redo_stack.clear();
281 }
282
283 fn push_undo(&mut self, op_id: clock::Local) {
284 assert_ne!(self.transaction_depth, 0);
285 if let Some(Operation::Edit(edit)) = self.operations.get(&op_id) {
286 let last_transaction = self.undo_stack.last_mut().unwrap();
287 last_transaction.push_edit(&edit);
288 }
289 }
290
291 fn pop_undo(&mut self) -> Option<&HistoryEntry> {
292 assert_eq!(self.transaction_depth, 0);
293 if let Some(entry) = self.undo_stack.pop() {
294 self.redo_stack.push(entry);
295 self.redo_stack.last()
296 } else {
297 None
298 }
299 }
300
301 fn remove_from_undo(&mut self, transaction_id: TransactionId) -> &[HistoryEntry] {
302 assert_eq!(self.transaction_depth, 0);
303
304 let redo_stack_start_len = self.redo_stack.len();
305 if let Some(entry_ix) = self
306 .undo_stack
307 .iter()
308 .rposition(|entry| entry.transaction.id == transaction_id)
309 {
310 self.redo_stack
311 .extend(self.undo_stack.drain(entry_ix..).rev());
312 }
313 &self.redo_stack[redo_stack_start_len..]
314 }
315
316 fn forget(&mut self, transaction_id: TransactionId) {
317 assert_eq!(self.transaction_depth, 0);
318 if let Some(entry_ix) = self
319 .undo_stack
320 .iter()
321 .rposition(|entry| entry.transaction.id == transaction_id)
322 {
323 self.undo_stack.remove(entry_ix);
324 } else if let Some(entry_ix) = self
325 .redo_stack
326 .iter()
327 .rposition(|entry| entry.transaction.id == transaction_id)
328 {
329 self.undo_stack.remove(entry_ix);
330 }
331 }
332
333 fn pop_redo(&mut self) -> Option<&HistoryEntry> {
334 assert_eq!(self.transaction_depth, 0);
335 if let Some(entry) = self.redo_stack.pop() {
336 self.undo_stack.push(entry);
337 self.undo_stack.last()
338 } else {
339 None
340 }
341 }
342
343 fn remove_from_redo(&mut self, transaction_id: TransactionId) -> &[HistoryEntry] {
344 assert_eq!(self.transaction_depth, 0);
345
346 let undo_stack_start_len = self.undo_stack.len();
347 if let Some(entry_ix) = self
348 .redo_stack
349 .iter()
350 .rposition(|entry| entry.transaction.id == transaction_id)
351 {
352 self.undo_stack
353 .extend(self.redo_stack.drain(entry_ix..).rev());
354 }
355 &self.undo_stack[undo_stack_start_len..]
356 }
357}
358
359#[derive(Clone, Default, Debug)]
360struct UndoMap(HashMap<clock::Local, Vec<(clock::Local, u32)>>);
361
362impl UndoMap {
363 fn insert(&mut self, undo: &UndoOperation) {
364 for (edit_id, count) in &undo.counts {
365 self.0.entry(*edit_id).or_default().push((undo.id, *count));
366 }
367 }
368
369 fn is_undone(&self, edit_id: clock::Local) -> bool {
370 self.undo_count(edit_id) % 2 == 1
371 }
372
373 fn was_undone(&self, edit_id: clock::Local, version: &clock::Global) -> bool {
374 let undo_count = self
375 .0
376 .get(&edit_id)
377 .unwrap_or(&Vec::new())
378 .iter()
379 .filter(|(undo_id, _)| version.observed(*undo_id))
380 .map(|(_, undo_count)| *undo_count)
381 .max()
382 .unwrap_or(0);
383 undo_count % 2 == 1
384 }
385
386 fn undo_count(&self, edit_id: clock::Local) -> u32 {
387 self.0
388 .get(&edit_id)
389 .unwrap_or(&Vec::new())
390 .iter()
391 .map(|(_, undo_count)| *undo_count)
392 .max()
393 .unwrap_or(0)
394 }
395}
396
397struct Edits<'a, D: TextDimension, F: FnMut(&FragmentSummary) -> bool> {
398 visible_cursor: rope::Cursor<'a>,
399 deleted_cursor: rope::Cursor<'a>,
400 fragments_cursor: Option<FilterCursor<'a, F, Fragment, FragmentTextSummary>>,
401 undos: &'a UndoMap,
402 since: &'a clock::Global,
403 old_end: D,
404 new_end: D,
405 range: Range<(&'a Locator, usize)>,
406}
407
408#[derive(Clone, Debug, Default, Eq, PartialEq)]
409pub struct Edit<D> {
410 pub old: Range<D>,
411 pub new: Range<D>,
412}
413
414impl<D> Edit<D>
415where
416 D: Sub<D, Output = D> + PartialEq + Copy,
417{
418 pub fn old_len(&self) -> D {
419 self.old.end - self.old.start
420 }
421
422 pub fn new_len(&self) -> D {
423 self.new.end - self.new.start
424 }
425
426 pub fn is_empty(&self) -> bool {
427 self.old.start == self.old.end && self.new.start == self.new.end
428 }
429}
430
431impl<D1, D2> Edit<(D1, D2)> {
432 pub fn flatten(self) -> (Edit<D1>, Edit<D2>) {
433 (
434 Edit {
435 old: self.old.start.0..self.old.end.0,
436 new: self.new.start.0..self.new.end.0,
437 },
438 Edit {
439 old: self.old.start.1..self.old.end.1,
440 new: self.new.start.1..self.new.end.1,
441 },
442 )
443 }
444}
445
446#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
447pub struct InsertionTimestamp {
448 pub replica_id: ReplicaId,
449 pub local: clock::Seq,
450 pub lamport: clock::Seq,
451}
452
453impl InsertionTimestamp {
454 pub fn local(&self) -> clock::Local {
455 clock::Local {
456 replica_id: self.replica_id,
457 value: self.local,
458 }
459 }
460
461 pub fn lamport(&self) -> clock::Lamport {
462 clock::Lamport {
463 replica_id: self.replica_id,
464 value: self.lamport,
465 }
466 }
467}
468
469#[derive(Eq, PartialEq, Clone, Debug)]
470pub struct Fragment {
471 pub id: Locator,
472 pub insertion_timestamp: InsertionTimestamp,
473 pub insertion_offset: usize,
474 pub len: usize,
475 pub visible: bool,
476 pub deletions: HashSet<clock::Local>,
477 pub max_undos: clock::Global,
478}
479
480#[derive(Eq, PartialEq, Clone, Debug)]
481pub struct FragmentSummary {
482 text: FragmentTextSummary,
483 max_id: Locator,
484 max_version: clock::Global,
485 min_insertion_version: clock::Global,
486 max_insertion_version: clock::Global,
487}
488
489#[derive(Copy, Default, Clone, Debug, PartialEq, Eq)]
490struct FragmentTextSummary {
491 visible: usize,
492 deleted: usize,
493}
494
495impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FragmentTextSummary {
496 fn add_summary(&mut self, summary: &'a FragmentSummary, _: &Option<clock::Global>) {
497 self.visible += summary.text.visible;
498 self.deleted += summary.text.deleted;
499 }
500}
501
502#[derive(Eq, PartialEq, Clone, Debug)]
503struct InsertionFragment {
504 timestamp: clock::Local,
505 split_offset: usize,
506 fragment_id: Locator,
507}
508
509#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
510struct InsertionFragmentKey {
511 timestamp: clock::Local,
512 split_offset: usize,
513}
514
515#[derive(Clone, Debug, Eq, PartialEq)]
516pub enum Operation {
517 Edit(EditOperation),
518 Undo {
519 undo: UndoOperation,
520 lamport_timestamp: clock::Lamport,
521 },
522}
523
524#[derive(Clone, Debug, Eq, PartialEq)]
525pub struct EditOperation {
526 pub timestamp: InsertionTimestamp,
527 pub version: clock::Global,
528 pub ranges: Vec<Range<FullOffset>>,
529 pub new_text: Vec<Arc<str>>,
530}
531
532#[derive(Clone, Debug, Eq, PartialEq)]
533pub struct UndoOperation {
534 pub id: clock::Local,
535 pub counts: HashMap<clock::Local, u32>,
536 pub transaction_ranges: Vec<Range<FullOffset>>,
537 pub transaction_version: clock::Global,
538 pub version: clock::Global,
539}
540
541impl Buffer {
542 pub fn new(replica_id: u16, remote_id: u64, history: History) -> Buffer {
543 let mut fragments = SumTree::new();
544 let mut insertions = SumTree::new();
545
546 let mut local_clock = clock::Local::new(replica_id);
547 let mut lamport_clock = clock::Lamport::new(replica_id);
548 let mut version = clock::Global::new();
549 let visible_text = Rope::from(history.base_text.as_ref());
550 if visible_text.len() > 0 {
551 let insertion_timestamp = InsertionTimestamp {
552 replica_id: 0,
553 local: 1,
554 lamport: 1,
555 };
556 local_clock.observe(insertion_timestamp.local());
557 lamport_clock.observe(insertion_timestamp.lamport());
558 version.observe(insertion_timestamp.local());
559 let fragment_id = Locator::between(&Locator::min(), &Locator::max());
560 let fragment = Fragment {
561 id: fragment_id,
562 insertion_timestamp,
563 insertion_offset: 0,
564 len: visible_text.len(),
565 visible: true,
566 deletions: Default::default(),
567 max_undos: Default::default(),
568 };
569 insertions.push(InsertionFragment::new(&fragment), &());
570 fragments.push(fragment, &None);
571 }
572
573 Buffer {
574 snapshot: BufferSnapshot {
575 replica_id,
576 remote_id,
577 visible_text,
578 deleted_text: Rope::new(),
579 fragments,
580 insertions,
581 version,
582 undo_map: Default::default(),
583 },
584 history,
585 deferred_ops: OperationQueue::new(),
586 deferred_replicas: HashSet::default(),
587 replica_id,
588 local_clock,
589 lamport_clock,
590 subscriptions: Default::default(),
591 edit_id_resolvers: Default::default(),
592 version_barriers: Default::default(),
593 }
594 }
595
596 pub fn version(&self) -> clock::Global {
597 self.version.clone()
598 }
599
600 pub fn snapshot(&self) -> BufferSnapshot {
601 self.snapshot.clone()
602 }
603
604 pub fn replica_id(&self) -> ReplicaId {
605 self.local_clock.replica_id
606 }
607
608 pub fn remote_id(&self) -> u64 {
609 self.remote_id
610 }
611
612 pub fn deferred_ops_len(&self) -> usize {
613 self.deferred_ops.len()
614 }
615
616 pub fn transaction_group_interval(&self) -> Duration {
617 self.history.group_interval
618 }
619
620 pub fn edit<R, I, S, T>(&mut self, edits: R) -> Operation
621 where
622 R: IntoIterator<IntoIter = I>,
623 I: ExactSizeIterator<Item = (Range<S>, T)>,
624 S: ToOffset,
625 T: Into<Arc<str>>,
626 {
627 let edits = edits
628 .into_iter()
629 .map(|(range, new_text)| (range, new_text.into()));
630
631 self.start_transaction();
632 let timestamp = InsertionTimestamp {
633 replica_id: self.replica_id,
634 local: self.local_clock.tick().value,
635 lamport: self.lamport_clock.tick().value,
636 };
637 let operation = Operation::Edit(self.apply_local_edit(edits, timestamp));
638
639 self.history.push(operation.clone());
640 self.history.push_undo(operation.local_timestamp());
641 self.snapshot.version.observe(operation.local_timestamp());
642 self.end_transaction();
643 operation
644 }
645
646 fn apply_local_edit<S: ToOffset, T: Into<Arc<str>>>(
647 &mut self,
648 edits: impl ExactSizeIterator<Item = (Range<S>, T)>,
649 timestamp: InsertionTimestamp,
650 ) -> EditOperation {
651 let mut edits_patch = Patch::default();
652 let mut edit_op = EditOperation {
653 timestamp,
654 version: self.version(),
655 ranges: Vec::with_capacity(edits.len()),
656 new_text: Vec::with_capacity(edits.len()),
657 };
658 let mut new_insertions = Vec::new();
659 let mut insertion_offset = 0;
660
661 let mut ranges = edits
662 .map(|(range, new_text)| (range.to_offset(&*self), new_text))
663 .peekable();
664
665 let mut new_ropes =
666 RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
667 let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>();
668 let mut new_fragments =
669 old_fragments.slice(&ranges.peek().unwrap().0.start, Bias::Right, &None);
670 new_ropes.push_tree(new_fragments.summary().text);
671
672 let mut fragment_start = old_fragments.start().visible;
673 for (range, new_text) in ranges {
674 let new_text = new_text.into();
675 let fragment_end = old_fragments.end(&None).visible;
676
677 // If the current fragment ends before this range, then jump ahead to the first fragment
678 // that extends past the start of this range, reusing any intervening fragments.
679 if fragment_end < range.start {
680 // If the current fragment has been partially consumed, then consume the rest of it
681 // and advance to the next fragment before slicing.
682 if fragment_start > old_fragments.start().visible {
683 if fragment_end > fragment_start {
684 let mut suffix = old_fragments.item().unwrap().clone();
685 suffix.len = fragment_end - fragment_start;
686 suffix.insertion_offset += fragment_start - old_fragments.start().visible;
687 new_insertions.push(InsertionFragment::insert_new(&suffix));
688 new_ropes.push_fragment(&suffix, suffix.visible);
689 new_fragments.push(suffix, &None);
690 }
691 old_fragments.next(&None);
692 }
693
694 let slice = old_fragments.slice(&range.start, Bias::Right, &None);
695 new_ropes.push_tree(slice.summary().text);
696 new_fragments.push_tree(slice, &None);
697 fragment_start = old_fragments.start().visible;
698 }
699
700 let full_range_start = FullOffset(range.start + old_fragments.start().deleted);
701
702 // Preserve any portion of the current fragment that precedes this range.
703 if fragment_start < range.start {
704 let mut prefix = old_fragments.item().unwrap().clone();
705 prefix.len = range.start - fragment_start;
706 prefix.insertion_offset += fragment_start - old_fragments.start().visible;
707 prefix.id = Locator::between(&new_fragments.summary().max_id, &prefix.id);
708 new_insertions.push(InsertionFragment::insert_new(&prefix));
709 new_ropes.push_fragment(&prefix, prefix.visible);
710 new_fragments.push(prefix, &None);
711 fragment_start = range.start;
712 }
713
714 // Insert the new text before any existing fragments within the range.
715 if !new_text.is_empty() {
716 let new_start = new_fragments.summary().text.visible;
717 edits_patch.push(Edit {
718 old: fragment_start..fragment_start,
719 new: new_start..new_start + new_text.len(),
720 });
721 let fragment = Fragment {
722 id: Locator::between(
723 &new_fragments.summary().max_id,
724 old_fragments
725 .item()
726 .map_or(&Locator::max(), |old_fragment| &old_fragment.id),
727 ),
728 insertion_timestamp: timestamp,
729 insertion_offset,
730 len: new_text.len(),
731 deletions: Default::default(),
732 max_undos: Default::default(),
733 visible: true,
734 };
735 new_insertions.push(InsertionFragment::insert_new(&fragment));
736 new_ropes.push_str(new_text.as_ref());
737 new_fragments.push(fragment, &None);
738 insertion_offset += new_text.len();
739 }
740
741 // Advance through every fragment that intersects this range, marking the intersecting
742 // portions as deleted.
743 while fragment_start < range.end {
744 let fragment = old_fragments.item().unwrap();
745 let fragment_end = old_fragments.end(&None).visible;
746 let mut intersection = fragment.clone();
747 let intersection_end = cmp::min(range.end, fragment_end);
748 if fragment.visible {
749 intersection.len = intersection_end - fragment_start;
750 intersection.insertion_offset += fragment_start - old_fragments.start().visible;
751 intersection.id =
752 Locator::between(&new_fragments.summary().max_id, &intersection.id);
753 intersection.deletions.insert(timestamp.local());
754 intersection.visible = false;
755 }
756 if intersection.len > 0 {
757 if fragment.visible && !intersection.visible {
758 let new_start = new_fragments.summary().text.visible;
759 edits_patch.push(Edit {
760 old: fragment_start..intersection_end,
761 new: new_start..new_start,
762 });
763 }
764 new_insertions.push(InsertionFragment::insert_new(&intersection));
765 new_ropes.push_fragment(&intersection, fragment.visible);
766 new_fragments.push(intersection, &None);
767 fragment_start = intersection_end;
768 }
769 if fragment_end <= range.end {
770 old_fragments.next(&None);
771 }
772 }
773
774 let full_range_end = FullOffset(range.end + old_fragments.start().deleted);
775 edit_op.ranges.push(full_range_start..full_range_end);
776 edit_op.new_text.push(new_text);
777 }
778
779 // If the current fragment has been partially consumed, then consume the rest of it
780 // and advance to the next fragment before slicing.
781 if fragment_start > old_fragments.start().visible {
782 let fragment_end = old_fragments.end(&None).visible;
783 if fragment_end > fragment_start {
784 let mut suffix = old_fragments.item().unwrap().clone();
785 suffix.len = fragment_end - fragment_start;
786 suffix.insertion_offset += fragment_start - old_fragments.start().visible;
787 new_insertions.push(InsertionFragment::insert_new(&suffix));
788 new_ropes.push_fragment(&suffix, suffix.visible);
789 new_fragments.push(suffix, &None);
790 }
791 old_fragments.next(&None);
792 }
793
794 let suffix = old_fragments.suffix(&None);
795 new_ropes.push_tree(suffix.summary().text);
796 new_fragments.push_tree(suffix, &None);
797 let (visible_text, deleted_text) = new_ropes.finish();
798 drop(old_fragments);
799
800 self.snapshot.fragments = new_fragments;
801 self.snapshot.insertions.edit(new_insertions, &());
802 self.snapshot.visible_text = visible_text;
803 self.snapshot.deleted_text = deleted_text;
804 self.subscriptions.publish_mut(&edits_patch);
805 edit_op
806 }
807
808 pub fn apply_ops<I: IntoIterator<Item = Operation>>(&mut self, ops: I) -> Result<()> {
809 let mut deferred_ops = Vec::new();
810 for op in ops {
811 self.history.push(op.clone());
812 if self.can_apply_op(&op) {
813 self.apply_op(op)?;
814 } else {
815 self.deferred_replicas.insert(op.replica_id());
816 deferred_ops.push(op);
817 }
818 }
819 self.deferred_ops.insert(deferred_ops);
820 self.flush_deferred_ops()?;
821 Ok(())
822 }
823
824 fn apply_op(&mut self, op: Operation) -> Result<()> {
825 match op {
826 Operation::Edit(edit) => {
827 if !self.version.observed(edit.timestamp.local()) {
828 self.apply_remote_edit(
829 &edit.version,
830 &edit.ranges,
831 &edit.new_text,
832 edit.timestamp,
833 );
834 self.snapshot.version.observe(edit.timestamp.local());
835 self.local_clock.observe(edit.timestamp.local());
836 self.lamport_clock.observe(edit.timestamp.lamport());
837 self.resolve_edit(edit.timestamp.local());
838 }
839 }
840 Operation::Undo {
841 undo,
842 lamport_timestamp,
843 } => {
844 if !self.version.observed(undo.id) {
845 self.apply_undo(&undo)?;
846 self.snapshot.version.observe(undo.id);
847 self.local_clock.observe(undo.id);
848 self.lamport_clock.observe(lamport_timestamp);
849 }
850 }
851 }
852 self.version_barriers
853 .retain(|(version, _)| !self.snapshot.version().observed_all(version));
854 Ok(())
855 }
856
857 fn apply_remote_edit(
858 &mut self,
859 version: &clock::Global,
860 ranges: &[Range<FullOffset>],
861 new_text: &[Arc<str>],
862 timestamp: InsertionTimestamp,
863 ) {
864 if ranges.is_empty() {
865 return;
866 }
867
868 let edits = ranges.into_iter().zip(new_text.into_iter());
869 let mut edits_patch = Patch::default();
870 let cx = Some(version.clone());
871 let mut new_insertions = Vec::new();
872 let mut insertion_offset = 0;
873 let mut new_ropes =
874 RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
875 let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>();
876 let mut new_fragments = old_fragments.slice(
877 &VersionedFullOffset::Offset(ranges[0].start),
878 Bias::Left,
879 &cx,
880 );
881 new_ropes.push_tree(new_fragments.summary().text);
882
883 let mut fragment_start = old_fragments.start().0.full_offset();
884 for (range, new_text) in edits {
885 let fragment_end = old_fragments.end(&cx).0.full_offset();
886
887 // If the current fragment ends before this range, then jump ahead to the first fragment
888 // that extends past the start of this range, reusing any intervening fragments.
889 if fragment_end < range.start {
890 // If the current fragment has been partially consumed, then consume the rest of it
891 // and advance to the next fragment before slicing.
892 if fragment_start > old_fragments.start().0.full_offset() {
893 if fragment_end > fragment_start {
894 let mut suffix = old_fragments.item().unwrap().clone();
895 suffix.len = fragment_end.0 - fragment_start.0;
896 suffix.insertion_offset +=
897 fragment_start - old_fragments.start().0.full_offset();
898 new_insertions.push(InsertionFragment::insert_new(&suffix));
899 new_ropes.push_fragment(&suffix, suffix.visible);
900 new_fragments.push(suffix, &None);
901 }
902 old_fragments.next(&cx);
903 }
904
905 let slice =
906 old_fragments.slice(&VersionedFullOffset::Offset(range.start), Bias::Left, &cx);
907 new_ropes.push_tree(slice.summary().text);
908 new_fragments.push_tree(slice, &None);
909 fragment_start = old_fragments.start().0.full_offset();
910 }
911
912 // If we are at the end of a non-concurrent fragment, advance to the next one.
913 let fragment_end = old_fragments.end(&cx).0.full_offset();
914 if fragment_end == range.start && fragment_end > fragment_start {
915 let mut fragment = old_fragments.item().unwrap().clone();
916 fragment.len = fragment_end.0 - fragment_start.0;
917 fragment.insertion_offset += fragment_start - old_fragments.start().0.full_offset();
918 new_insertions.push(InsertionFragment::insert_new(&fragment));
919 new_ropes.push_fragment(&fragment, fragment.visible);
920 new_fragments.push(fragment, &None);
921 old_fragments.next(&cx);
922 fragment_start = old_fragments.start().0.full_offset();
923 }
924
925 // Skip over insertions that are concurrent to this edit, but have a lower lamport
926 // timestamp.
927 while let Some(fragment) = old_fragments.item() {
928 if fragment_start == range.start
929 && fragment.insertion_timestamp.lamport() > timestamp.lamport()
930 {
931 new_ropes.push_fragment(fragment, fragment.visible);
932 new_fragments.push(fragment.clone(), &None);
933 old_fragments.next(&cx);
934 debug_assert_eq!(fragment_start, range.start);
935 } else {
936 break;
937 }
938 }
939 debug_assert!(fragment_start <= range.start);
940
941 // Preserve any portion of the current fragment that precedes this range.
942 if fragment_start < range.start {
943 let mut prefix = old_fragments.item().unwrap().clone();
944 prefix.len = range.start.0 - fragment_start.0;
945 prefix.insertion_offset += fragment_start - old_fragments.start().0.full_offset();
946 prefix.id = Locator::between(&new_fragments.summary().max_id, &prefix.id);
947 new_insertions.push(InsertionFragment::insert_new(&prefix));
948 fragment_start = range.start;
949 new_ropes.push_fragment(&prefix, prefix.visible);
950 new_fragments.push(prefix, &None);
951 }
952
953 // Insert the new text before any existing fragments within the range.
954 if !new_text.is_empty() {
955 let mut old_start = old_fragments.start().1;
956 if old_fragments.item().map_or(false, |f| f.visible) {
957 old_start += fragment_start.0 - old_fragments.start().0.full_offset().0;
958 }
959 let new_start = new_fragments.summary().text.visible;
960 edits_patch.push(Edit {
961 old: old_start..old_start,
962 new: new_start..new_start + new_text.len(),
963 });
964 let fragment = Fragment {
965 id: Locator::between(
966 &new_fragments.summary().max_id,
967 old_fragments
968 .item()
969 .map_or(&Locator::max(), |old_fragment| &old_fragment.id),
970 ),
971 insertion_timestamp: timestamp,
972 insertion_offset,
973 len: new_text.len(),
974 deletions: Default::default(),
975 max_undos: Default::default(),
976 visible: true,
977 };
978 new_insertions.push(InsertionFragment::insert_new(&fragment));
979 new_ropes.push_str(new_text);
980 new_fragments.push(fragment, &None);
981 insertion_offset += new_text.len();
982 }
983
984 // Advance through every fragment that intersects this range, marking the intersecting
985 // portions as deleted.
986 while fragment_start < range.end {
987 let fragment = old_fragments.item().unwrap();
988 let fragment_end = old_fragments.end(&cx).0.full_offset();
989 let mut intersection = fragment.clone();
990 let intersection_end = cmp::min(range.end, fragment_end);
991 if fragment.was_visible(version, &self.undo_map) {
992 intersection.len = intersection_end.0 - fragment_start.0;
993 intersection.insertion_offset +=
994 fragment_start - old_fragments.start().0.full_offset();
995 intersection.id =
996 Locator::between(&new_fragments.summary().max_id, &intersection.id);
997 intersection.deletions.insert(timestamp.local());
998 intersection.visible = false;
999 }
1000 if intersection.len > 0 {
1001 if fragment.visible && !intersection.visible {
1002 let old_start = old_fragments.start().1
1003 + (fragment_start.0 - old_fragments.start().0.full_offset().0);
1004 let new_start = new_fragments.summary().text.visible;
1005 edits_patch.push(Edit {
1006 old: old_start..old_start + intersection.len,
1007 new: new_start..new_start,
1008 });
1009 }
1010 new_insertions.push(InsertionFragment::insert_new(&intersection));
1011 new_ropes.push_fragment(&intersection, fragment.visible);
1012 new_fragments.push(intersection, &None);
1013 fragment_start = intersection_end;
1014 }
1015 if fragment_end <= range.end {
1016 old_fragments.next(&cx);
1017 }
1018 }
1019 }
1020
1021 // If the current fragment has been partially consumed, then consume the rest of it
1022 // and advance to the next fragment before slicing.
1023 if fragment_start > old_fragments.start().0.full_offset() {
1024 let fragment_end = old_fragments.end(&cx).0.full_offset();
1025 if fragment_end > fragment_start {
1026 let mut suffix = old_fragments.item().unwrap().clone();
1027 suffix.len = fragment_end.0 - fragment_start.0;
1028 suffix.insertion_offset += fragment_start - old_fragments.start().0.full_offset();
1029 new_insertions.push(InsertionFragment::insert_new(&suffix));
1030 new_ropes.push_fragment(&suffix, suffix.visible);
1031 new_fragments.push(suffix, &None);
1032 }
1033 old_fragments.next(&cx);
1034 }
1035
1036 let suffix = old_fragments.suffix(&cx);
1037 new_ropes.push_tree(suffix.summary().text);
1038 new_fragments.push_tree(suffix, &None);
1039 let (visible_text, deleted_text) = new_ropes.finish();
1040 drop(old_fragments);
1041
1042 self.snapshot.fragments = new_fragments;
1043 self.snapshot.visible_text = visible_text;
1044 self.snapshot.deleted_text = deleted_text;
1045 self.snapshot.insertions.edit(new_insertions, &());
1046 self.subscriptions.publish_mut(&edits_patch)
1047 }
1048
1049 fn apply_undo(&mut self, undo: &UndoOperation) -> Result<()> {
1050 let mut edits = Patch::default();
1051 self.snapshot.undo_map.insert(undo);
1052
1053 let mut cx = undo.transaction_version.clone();
1054 for edit_id in undo.counts.keys().copied() {
1055 cx.observe(edit_id);
1056 }
1057 let cx = Some(cx);
1058
1059 let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>();
1060 let mut new_fragments = old_fragments.slice(
1061 &VersionedFullOffset::Offset(undo.transaction_ranges[0].start),
1062 Bias::Right,
1063 &cx,
1064 );
1065 let mut new_ropes =
1066 RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
1067 new_ropes.push_tree(new_fragments.summary().text);
1068
1069 for range in &undo.transaction_ranges {
1070 let mut end_offset = old_fragments.end(&cx).0.full_offset();
1071
1072 if end_offset < range.start {
1073 let preceding_fragments = old_fragments.slice(
1074 &VersionedFullOffset::Offset(range.start),
1075 Bias::Right,
1076 &cx,
1077 );
1078 new_ropes.push_tree(preceding_fragments.summary().text);
1079 new_fragments.push_tree(preceding_fragments, &None);
1080 }
1081
1082 while end_offset <= range.end {
1083 if let Some(fragment) = old_fragments.item() {
1084 let mut fragment = fragment.clone();
1085 let fragment_was_visible = fragment.visible;
1086
1087 if fragment.was_visible(&undo.transaction_version, &self.undo_map)
1088 || undo
1089 .counts
1090 .contains_key(&fragment.insertion_timestamp.local())
1091 {
1092 fragment.visible = fragment.is_visible(&self.undo_map);
1093 fragment.max_undos.observe(undo.id);
1094 }
1095
1096 let old_start = old_fragments.start().1;
1097 let new_start = new_fragments.summary().text.visible;
1098 if fragment_was_visible && !fragment.visible {
1099 edits.push(Edit {
1100 old: old_start..old_start + fragment.len,
1101 new: new_start..new_start,
1102 });
1103 } else if !fragment_was_visible && fragment.visible {
1104 edits.push(Edit {
1105 old: old_start..old_start,
1106 new: new_start..new_start + fragment.len,
1107 });
1108 }
1109 new_ropes.push_fragment(&fragment, fragment_was_visible);
1110 new_fragments.push(fragment, &None);
1111
1112 old_fragments.next(&cx);
1113 if end_offset == old_fragments.end(&cx).0.full_offset() {
1114 let unseen_fragments = old_fragments.slice(
1115 &VersionedFullOffset::Offset(end_offset),
1116 Bias::Right,
1117 &cx,
1118 );
1119 new_ropes.push_tree(unseen_fragments.summary().text);
1120 new_fragments.push_tree(unseen_fragments, &None);
1121 }
1122 end_offset = old_fragments.end(&cx).0.full_offset();
1123 } else {
1124 break;
1125 }
1126 }
1127 }
1128
1129 let suffix = old_fragments.suffix(&cx);
1130 new_ropes.push_tree(suffix.summary().text);
1131 new_fragments.push_tree(suffix, &None);
1132
1133 drop(old_fragments);
1134 let (visible_text, deleted_text) = new_ropes.finish();
1135 self.snapshot.fragments = new_fragments;
1136 self.snapshot.visible_text = visible_text;
1137 self.snapshot.deleted_text = deleted_text;
1138 self.subscriptions.publish_mut(&edits);
1139 Ok(())
1140 }
1141
1142 fn flush_deferred_ops(&mut self) -> Result<()> {
1143 self.deferred_replicas.clear();
1144 let mut deferred_ops = Vec::new();
1145 for op in self.deferred_ops.drain().iter().cloned() {
1146 if self.can_apply_op(&op) {
1147 self.apply_op(op)?;
1148 } else {
1149 self.deferred_replicas.insert(op.replica_id());
1150 deferred_ops.push(op);
1151 }
1152 }
1153 self.deferred_ops.insert(deferred_ops);
1154 Ok(())
1155 }
1156
1157 fn can_apply_op(&self, op: &Operation) -> bool {
1158 if self.deferred_replicas.contains(&op.replica_id()) {
1159 false
1160 } else {
1161 match op {
1162 Operation::Edit(edit) => self.version.observed_all(&edit.version),
1163 Operation::Undo { undo, .. } => self.version.observed_all(&undo.version),
1164 }
1165 }
1166 }
1167
1168 pub fn peek_undo_stack(&self) -> Option<&HistoryEntry> {
1169 self.history.undo_stack.last()
1170 }
1171
1172 pub fn peek_redo_stack(&self) -> Option<&HistoryEntry> {
1173 self.history.redo_stack.last()
1174 }
1175
1176 pub fn start_transaction(&mut self) -> Option<TransactionId> {
1177 self.start_transaction_at(Instant::now())
1178 }
1179
1180 pub fn start_transaction_at(&mut self, now: Instant) -> Option<TransactionId> {
1181 self.history
1182 .start_transaction(self.version.clone(), now, &mut self.local_clock)
1183 }
1184
1185 pub fn end_transaction(&mut self) -> Option<(TransactionId, clock::Global)> {
1186 self.end_transaction_at(Instant::now())
1187 }
1188
1189 pub fn end_transaction_at(&mut self, now: Instant) -> Option<(TransactionId, clock::Global)> {
1190 if let Some(entry) = self.history.end_transaction(now) {
1191 let since = entry.transaction.start.clone();
1192 let id = self.history.group().unwrap();
1193 Some((id, since))
1194 } else {
1195 None
1196 }
1197 }
1198
1199 pub fn finalize_last_transaction(&mut self) -> Option<&Transaction> {
1200 self.history.finalize_last_transaction()
1201 }
1202
1203 pub fn base_text(&self) -> &Arc<str> {
1204 &self.history.base_text
1205 }
1206
1207 pub fn history(&self) -> impl Iterator<Item = &Operation> {
1208 self.history.operations.values()
1209 }
1210
1211 pub fn undo_history(&self) -> impl Iterator<Item = (&clock::Local, &[(clock::Local, u32)])> {
1212 self.undo_map
1213 .0
1214 .iter()
1215 .map(|(edit_id, undo_counts)| (edit_id, undo_counts.as_slice()))
1216 }
1217
1218 pub fn undo(&mut self) -> Option<(TransactionId, Operation)> {
1219 if let Some(entry) = self.history.pop_undo() {
1220 let transaction = entry.transaction.clone();
1221 let transaction_id = transaction.id;
1222 let op = self.undo_or_redo(transaction).unwrap();
1223 Some((transaction_id, op))
1224 } else {
1225 None
1226 }
1227 }
1228
1229 pub fn undo_to_transaction(&mut self, transaction_id: TransactionId) -> Vec<Operation> {
1230 let transactions = self
1231 .history
1232 .remove_from_undo(transaction_id)
1233 .iter()
1234 .map(|entry| entry.transaction.clone())
1235 .collect::<Vec<_>>();
1236 transactions
1237 .into_iter()
1238 .map(|transaction| self.undo_or_redo(transaction).unwrap())
1239 .collect()
1240 }
1241
1242 pub fn forget_transaction(&mut self, transaction_id: TransactionId) {
1243 self.history.forget(transaction_id);
1244 }
1245
1246 pub fn redo(&mut self) -> Option<(TransactionId, Operation)> {
1247 if let Some(entry) = self.history.pop_redo() {
1248 let transaction = entry.transaction.clone();
1249 let transaction_id = transaction.id;
1250 let op = self.undo_or_redo(transaction).unwrap();
1251 Some((transaction_id, op))
1252 } else {
1253 None
1254 }
1255 }
1256
1257 pub fn redo_to_transaction(&mut self, transaction_id: TransactionId) -> Vec<Operation> {
1258 let transactions = self
1259 .history
1260 .remove_from_redo(transaction_id)
1261 .iter()
1262 .map(|entry| entry.transaction.clone())
1263 .collect::<Vec<_>>();
1264 transactions
1265 .into_iter()
1266 .map(|transaction| self.undo_or_redo(transaction).unwrap())
1267 .collect()
1268 }
1269
1270 fn undo_or_redo(&mut self, transaction: Transaction) -> Result<Operation> {
1271 let mut counts = HashMap::default();
1272 for edit_id in transaction.edit_ids {
1273 counts.insert(edit_id, self.undo_map.undo_count(edit_id) + 1);
1274 }
1275
1276 let undo = UndoOperation {
1277 id: self.local_clock.tick(),
1278 version: self.version(),
1279 counts,
1280 transaction_ranges: transaction.ranges,
1281 transaction_version: transaction.start.clone(),
1282 };
1283 self.apply_undo(&undo)?;
1284 let operation = Operation::Undo {
1285 undo,
1286 lamport_timestamp: self.lamport_clock.tick(),
1287 };
1288 self.snapshot.version.observe(operation.local_timestamp());
1289 self.history.push(operation.clone());
1290 Ok(operation)
1291 }
1292
1293 pub fn push_transaction(&mut self, transaction: Transaction, now: Instant) {
1294 self.history.push_transaction(transaction, now);
1295 self.history.finalize_last_transaction();
1296 }
1297
1298 pub fn subscribe(&mut self) -> Subscription {
1299 self.subscriptions.subscribe()
1300 }
1301
1302 pub fn wait_for_edits(
1303 &mut self,
1304 edit_ids: impl IntoIterator<Item = clock::Local>,
1305 ) -> impl 'static + Future<Output = ()> {
1306 let mut futures = Vec::new();
1307 for edit_id in edit_ids {
1308 if !self.version.observed(edit_id) {
1309 let (tx, rx) = oneshot::channel();
1310 self.edit_id_resolvers.entry(edit_id).or_default().push(tx);
1311 futures.push(rx);
1312 }
1313 }
1314
1315 async move {
1316 for mut future in futures {
1317 future.recv().await;
1318 }
1319 }
1320 }
1321
1322 pub fn wait_for_anchors<'a>(
1323 &mut self,
1324 anchors: impl IntoIterator<Item = &'a Anchor>,
1325 ) -> impl 'static + Future<Output = ()> {
1326 let mut futures = Vec::new();
1327 for anchor in anchors {
1328 if !self.version.observed(anchor.timestamp)
1329 && *anchor != Anchor::MAX
1330 && *anchor != Anchor::MIN
1331 {
1332 let (tx, rx) = oneshot::channel();
1333 self.edit_id_resolvers
1334 .entry(anchor.timestamp)
1335 .or_default()
1336 .push(tx);
1337 futures.push(rx);
1338 }
1339 }
1340
1341 async move {
1342 for mut future in futures {
1343 future.recv().await;
1344 }
1345 }
1346 }
1347
1348 pub fn wait_for_version(&mut self, version: clock::Global) -> impl Future<Output = ()> {
1349 let (tx, mut rx) = barrier::channel();
1350 if !self.snapshot.version.observed_all(&version) {
1351 self.version_barriers.push((version, tx));
1352 }
1353 async move {
1354 rx.recv().await;
1355 }
1356 }
1357
1358 fn resolve_edit(&mut self, edit_id: clock::Local) {
1359 for mut tx in self
1360 .edit_id_resolvers
1361 .remove(&edit_id)
1362 .into_iter()
1363 .flatten()
1364 {
1365 let _ = tx.try_send(());
1366 }
1367 }
1368}
1369
1370#[cfg(any(test, feature = "test-support"))]
1371impl Buffer {
1372 pub fn check_invariants(&self) {
1373 // Ensure every fragment is ordered by locator in the fragment tree and corresponds
1374 // to an insertion fragment in the insertions tree.
1375 let mut prev_fragment_id = Locator::min();
1376 for fragment in self.snapshot.fragments.items(&None) {
1377 assert!(fragment.id > prev_fragment_id);
1378 prev_fragment_id = fragment.id.clone();
1379
1380 let insertion_fragment = self
1381 .snapshot
1382 .insertions
1383 .get(
1384 &InsertionFragmentKey {
1385 timestamp: fragment.insertion_timestamp.local(),
1386 split_offset: fragment.insertion_offset,
1387 },
1388 &(),
1389 )
1390 .unwrap();
1391 assert_eq!(
1392 insertion_fragment.fragment_id, fragment.id,
1393 "fragment: {:?}\ninsertion: {:?}",
1394 fragment, insertion_fragment
1395 );
1396 }
1397
1398 let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>();
1399 for insertion_fragment in self.snapshot.insertions.cursor::<()>() {
1400 cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None);
1401 let fragment = cursor.item().unwrap();
1402 assert_eq!(insertion_fragment.fragment_id, fragment.id);
1403 assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset);
1404 }
1405
1406 let fragment_summary = self.snapshot.fragments.summary();
1407 assert_eq!(
1408 fragment_summary.text.visible,
1409 self.snapshot.visible_text.len()
1410 );
1411 assert_eq!(
1412 fragment_summary.text.deleted,
1413 self.snapshot.deleted_text.len()
1414 );
1415 }
1416
1417 pub fn set_group_interval(&mut self, group_interval: Duration) {
1418 self.history.group_interval = group_interval;
1419 }
1420
1421 pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
1422 let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
1423 let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
1424 start..end
1425 }
1426
1427 pub fn randomly_edit<T>(
1428 &mut self,
1429 rng: &mut T,
1430 edit_count: usize,
1431 ) -> (Vec<(Range<usize>, Arc<str>)>, Operation)
1432 where
1433 T: rand::Rng,
1434 {
1435 let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
1436 let mut last_end = None;
1437 for _ in 0..edit_count {
1438 if last_end.map_or(false, |last_end| last_end >= self.len()) {
1439 break;
1440 }
1441 let new_start = last_end.map_or(0, |last_end| last_end + 1);
1442 let range = self.random_byte_range(new_start, rng);
1443 last_end = Some(range.end);
1444
1445 let new_text_len = rng.gen_range(0..10);
1446 let new_text: String = crate::random_char_iter::RandomCharIter::new(&mut *rng)
1447 .take(new_text_len)
1448 .collect();
1449
1450 edits.push((range, new_text.into()));
1451 }
1452
1453 log::info!("mutating buffer {} with {:?}", self.replica_id, edits);
1454 let op = self.edit(edits.iter().cloned());
1455 (edits, op)
1456 }
1457
1458 pub fn randomly_undo_redo(&mut self, rng: &mut impl rand::Rng) -> Vec<Operation> {
1459 use rand::prelude::*;
1460
1461 let mut ops = Vec::new();
1462 for _ in 0..rng.gen_range(1..=5) {
1463 if let Some(entry) = self.history.undo_stack.choose(rng) {
1464 let transaction = entry.transaction.clone();
1465 log::info!(
1466 "undoing buffer {} transaction {:?}",
1467 self.replica_id,
1468 transaction
1469 );
1470 ops.push(self.undo_or_redo(transaction).unwrap());
1471 }
1472 }
1473 ops
1474 }
1475}
1476
1477impl Deref for Buffer {
1478 type Target = BufferSnapshot;
1479
1480 fn deref(&self) -> &Self::Target {
1481 &self.snapshot
1482 }
1483}
1484
1485impl BufferSnapshot {
1486 pub fn as_rope(&self) -> &Rope {
1487 &self.visible_text
1488 }
1489
1490 pub fn replica_id(&self) -> ReplicaId {
1491 self.replica_id
1492 }
1493
1494 pub fn row_count(&self) -> u32 {
1495 self.max_point().row + 1
1496 }
1497
1498 pub fn len(&self) -> usize {
1499 self.visible_text.len()
1500 }
1501
1502 pub fn chars(&self) -> impl Iterator<Item = char> + '_ {
1503 self.chars_at(0)
1504 }
1505
1506 pub fn chars_for_range<T: ToOffset>(&self, range: Range<T>) -> impl Iterator<Item = char> + '_ {
1507 self.text_for_range(range).flat_map(str::chars)
1508 }
1509
1510 pub fn contains_str_at<T>(&self, position: T, needle: &str) -> bool
1511 where
1512 T: ToOffset,
1513 {
1514 let position = position.to_offset(self);
1515 position == self.clip_offset(position, Bias::Left)
1516 && self
1517 .bytes_in_range(position..self.len())
1518 .flatten()
1519 .copied()
1520 .take(needle.len())
1521 .eq(needle.bytes())
1522 }
1523
1524 pub fn common_prefix_at<T>(&self, position: T, needle: &str) -> Range<T>
1525 where
1526 T: ToOffset + TextDimension,
1527 {
1528 let offset = position.to_offset(self);
1529 let common_prefix_len = needle
1530 .char_indices()
1531 .map(|(index, _)| index)
1532 .chain([needle.len()])
1533 .take_while(|&len| len <= offset)
1534 .filter(|&len| {
1535 let left = self
1536 .chars_for_range(offset - len..offset)
1537 .flat_map(|c| char::to_lowercase(c));
1538 let right = needle[..len].chars().flat_map(|c| char::to_lowercase(c));
1539 left.eq(right)
1540 })
1541 .last()
1542 .unwrap_or(0);
1543 let start_offset = offset - common_prefix_len;
1544 let start = self.text_summary_for_range(0..start_offset);
1545 start..position
1546 }
1547
1548 pub fn text(&self) -> String {
1549 self.visible_text.to_string()
1550 }
1551
1552 pub fn deleted_text(&self) -> String {
1553 self.deleted_text.to_string()
1554 }
1555
1556 pub fn fragments(&self) -> impl Iterator<Item = &Fragment> {
1557 self.fragments.iter()
1558 }
1559
1560 pub fn text_summary(&self) -> TextSummary {
1561 self.visible_text.summary()
1562 }
1563
1564 pub fn max_point(&self) -> Point {
1565 self.visible_text.max_point()
1566 }
1567
1568 pub fn max_point_utf16(&self) -> PointUtf16 {
1569 self.visible_text.max_point_utf16()
1570 }
1571
1572 pub fn point_to_offset(&self, point: Point) -> usize {
1573 self.visible_text.point_to_offset(point)
1574 }
1575
1576 pub fn point_utf16_to_offset(&self, point: PointUtf16) -> usize {
1577 self.visible_text.point_utf16_to_offset(point)
1578 }
1579
1580 pub fn point_utf16_to_point(&self, point: PointUtf16) -> Point {
1581 self.visible_text.point_utf16_to_point(point)
1582 }
1583
1584 pub fn offset_to_point(&self, offset: usize) -> Point {
1585 self.visible_text.offset_to_point(offset)
1586 }
1587
1588 pub fn offset_to_point_utf16(&self, offset: usize) -> PointUtf16 {
1589 self.visible_text.offset_to_point_utf16(offset)
1590 }
1591
1592 pub fn point_to_point_utf16(&self, point: Point) -> PointUtf16 {
1593 self.visible_text.point_to_point_utf16(point)
1594 }
1595
1596 pub fn version(&self) -> &clock::Global {
1597 &self.version
1598 }
1599
1600 pub fn chars_at<'a, T: ToOffset>(&'a self, position: T) -> impl Iterator<Item = char> + 'a {
1601 let offset = position.to_offset(self);
1602 self.visible_text.chars_at(offset)
1603 }
1604
1605 pub fn reversed_chars_at<'a, T: ToOffset>(
1606 &'a self,
1607 position: T,
1608 ) -> impl Iterator<Item = char> + 'a {
1609 let offset = position.to_offset(self);
1610 self.visible_text.reversed_chars_at(offset)
1611 }
1612
1613 pub fn reversed_chunks_in_range<T: ToOffset>(&self, range: Range<T>) -> rope::Chunks {
1614 let range = range.start.to_offset(self)..range.end.to_offset(self);
1615 self.visible_text.reversed_chunks_in_range(range)
1616 }
1617
1618 pub fn bytes_in_range<'a, T: ToOffset>(&'a self, range: Range<T>) -> rope::Bytes<'a> {
1619 let start = range.start.to_offset(self);
1620 let end = range.end.to_offset(self);
1621 self.visible_text.bytes_in_range(start..end)
1622 }
1623
1624 pub fn text_for_range<'a, T: ToOffset>(&'a self, range: Range<T>) -> Chunks<'a> {
1625 let start = range.start.to_offset(self);
1626 let end = range.end.to_offset(self);
1627 self.visible_text.chunks_in_range(start..end)
1628 }
1629
1630 pub fn line_len(&self, row: u32) -> u32 {
1631 let row_start_offset = Point::new(row, 0).to_offset(self);
1632 let row_end_offset = if row >= self.max_point().row {
1633 self.len()
1634 } else {
1635 Point::new(row + 1, 0).to_offset(self) - 1
1636 };
1637 (row_end_offset - row_start_offset) as u32
1638 }
1639
1640 pub fn is_line_blank(&self, row: u32) -> bool {
1641 self.text_for_range(Point::new(row, 0)..Point::new(row, self.line_len(row)))
1642 .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
1643 }
1644
1645 pub fn indent_column_for_line(&self, row: u32) -> u32 {
1646 let mut result = 0;
1647 for c in self.chars_at(Point::new(row, 0)) {
1648 if c == ' ' {
1649 result += 1;
1650 } else {
1651 break;
1652 }
1653 }
1654 result
1655 }
1656
1657 pub fn text_summary_for_range<'a, D, O: ToOffset>(&'a self, range: Range<O>) -> D
1658 where
1659 D: TextDimension,
1660 {
1661 self.visible_text
1662 .cursor(range.start.to_offset(self))
1663 .summary(range.end.to_offset(self))
1664 }
1665
1666 pub fn summaries_for_anchors<'a, D, A>(&'a self, anchors: A) -> impl 'a + Iterator<Item = D>
1667 where
1668 D: 'a + TextDimension,
1669 A: 'a + IntoIterator<Item = &'a Anchor>,
1670 {
1671 let anchors = anchors.into_iter();
1672 let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
1673 let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>();
1674 let mut text_cursor = self.visible_text.cursor(0);
1675 let mut position = D::default();
1676
1677 anchors.map(move |anchor| {
1678 if *anchor == Anchor::MIN {
1679 return D::default();
1680 } else if *anchor == Anchor::MAX {
1681 return D::from_text_summary(&self.visible_text.summary());
1682 }
1683
1684 let anchor_key = InsertionFragmentKey {
1685 timestamp: anchor.timestamp,
1686 split_offset: anchor.offset,
1687 };
1688 insertion_cursor.seek(&anchor_key, anchor.bias, &());
1689 if let Some(insertion) = insertion_cursor.item() {
1690 let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
1691 if comparison == Ordering::Greater
1692 || (anchor.bias == Bias::Left
1693 && comparison == Ordering::Equal
1694 && anchor.offset > 0)
1695 {
1696 insertion_cursor.prev(&());
1697 }
1698 } else {
1699 insertion_cursor.prev(&());
1700 }
1701 let insertion = insertion_cursor.item().expect("invalid insertion");
1702 assert_eq!(insertion.timestamp, anchor.timestamp, "invalid insertion");
1703
1704 fragment_cursor.seek_forward(&Some(&insertion.fragment_id), Bias::Left, &None);
1705 let fragment = fragment_cursor.item().unwrap();
1706 let mut fragment_offset = fragment_cursor.start().1;
1707 if fragment.visible {
1708 fragment_offset += anchor.offset - insertion.split_offset;
1709 }
1710
1711 position.add_assign(&text_cursor.summary(fragment_offset));
1712 position.clone()
1713 })
1714 }
1715
1716 fn summary_for_anchor<'a, D>(&'a self, anchor: &Anchor) -> D
1717 where
1718 D: TextDimension,
1719 {
1720 if *anchor == Anchor::MIN {
1721 D::default()
1722 } else if *anchor == Anchor::MAX {
1723 D::from_text_summary(&self.visible_text.summary())
1724 } else {
1725 let anchor_key = InsertionFragmentKey {
1726 timestamp: anchor.timestamp,
1727 split_offset: anchor.offset,
1728 };
1729 let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
1730 insertion_cursor.seek(&anchor_key, anchor.bias, &());
1731 if let Some(insertion) = insertion_cursor.item() {
1732 let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
1733 if comparison == Ordering::Greater
1734 || (anchor.bias == Bias::Left
1735 && comparison == Ordering::Equal
1736 && anchor.offset > 0)
1737 {
1738 insertion_cursor.prev(&());
1739 }
1740 } else {
1741 insertion_cursor.prev(&());
1742 }
1743 let insertion = insertion_cursor.item().expect("invalid insertion");
1744 assert_eq!(insertion.timestamp, anchor.timestamp, "invalid insertion");
1745
1746 let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>();
1747 fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left, &None);
1748 let fragment = fragment_cursor.item().unwrap();
1749 let mut fragment_offset = fragment_cursor.start().1;
1750 if fragment.visible {
1751 fragment_offset += anchor.offset - insertion.split_offset;
1752 }
1753 self.text_summary_for_range(0..fragment_offset)
1754 }
1755 }
1756
1757 fn fragment_id_for_anchor(&self, anchor: &Anchor) -> &Locator {
1758 if *anchor == Anchor::MIN {
1759 &locator::MIN
1760 } else if *anchor == Anchor::MAX {
1761 &locator::MAX
1762 } else {
1763 let anchor_key = InsertionFragmentKey {
1764 timestamp: anchor.timestamp,
1765 split_offset: anchor.offset,
1766 };
1767 let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
1768 insertion_cursor.seek(&anchor_key, anchor.bias, &());
1769 if let Some(insertion) = insertion_cursor.item() {
1770 let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
1771 if comparison == Ordering::Greater
1772 || (anchor.bias == Bias::Left
1773 && comparison == Ordering::Equal
1774 && anchor.offset > 0)
1775 {
1776 insertion_cursor.prev(&());
1777 }
1778 } else {
1779 insertion_cursor.prev(&());
1780 }
1781 let insertion = insertion_cursor.item().expect("invalid insertion");
1782 debug_assert_eq!(insertion.timestamp, anchor.timestamp, "invalid insertion");
1783 &insertion.fragment_id
1784 }
1785 }
1786
1787 pub fn anchor_before<T: ToOffset>(&self, position: T) -> Anchor {
1788 self.anchor_at(position, Bias::Left)
1789 }
1790
1791 pub fn anchor_after<T: ToOffset>(&self, position: T) -> Anchor {
1792 self.anchor_at(position, Bias::Right)
1793 }
1794
1795 pub fn anchor_at<T: ToOffset>(&self, position: T, bias: Bias) -> Anchor {
1796 let offset = position.to_offset(self);
1797 if bias == Bias::Left && offset == 0 {
1798 Anchor::MIN
1799 } else if bias == Bias::Right && offset == self.len() {
1800 Anchor::MAX
1801 } else {
1802 let mut fragment_cursor = self.fragments.cursor::<usize>();
1803 fragment_cursor.seek(&offset, bias, &None);
1804 let fragment = fragment_cursor.item().unwrap();
1805 let overshoot = offset - *fragment_cursor.start();
1806 Anchor {
1807 timestamp: fragment.insertion_timestamp.local(),
1808 offset: fragment.insertion_offset + overshoot,
1809 bias,
1810 buffer_id: Some(self.remote_id),
1811 }
1812 }
1813 }
1814
1815 pub fn can_resolve(&self, anchor: &Anchor) -> bool {
1816 *anchor == Anchor::MIN
1817 || *anchor == Anchor::MAX
1818 || (Some(self.remote_id) == anchor.buffer_id && self.version.observed(anchor.timestamp))
1819 }
1820
1821 pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize {
1822 self.visible_text.clip_offset(offset, bias)
1823 }
1824
1825 pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
1826 self.visible_text.clip_point(point, bias)
1827 }
1828
1829 pub fn clip_point_utf16(&self, point: PointUtf16, bias: Bias) -> PointUtf16 {
1830 self.visible_text.clip_point_utf16(point, bias)
1831 }
1832
1833 pub fn edits_since<'a, D>(
1834 &'a self,
1835 since: &'a clock::Global,
1836 ) -> impl 'a + Iterator<Item = Edit<D>>
1837 where
1838 D: TextDimension + Ord,
1839 {
1840 self.edits_since_in_range(since, Anchor::MIN..Anchor::MAX)
1841 }
1842
1843 pub fn edited_ranges_for_transaction<'a, D>(
1844 &'a self,
1845 transaction: &'a Transaction,
1846 ) -> impl 'a + Iterator<Item = Range<D>>
1847 where
1848 D: TextDimension,
1849 {
1850 let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
1851 let mut rope_cursor = self.visible_text.cursor(0);
1852 let cx = Some(transaction.end.clone());
1853 let mut position = D::default();
1854 transaction.ranges.iter().map(move |range| {
1855 cursor.seek_forward(&VersionedFullOffset::Offset(range.start), Bias::Right, &cx);
1856 let mut start_offset = cursor.start().1;
1857 if cursor
1858 .item()
1859 .map_or(false, |fragment| fragment.is_visible(&self.undo_map))
1860 {
1861 start_offset += range.start - cursor.start().0.full_offset()
1862 }
1863 position.add_assign(&rope_cursor.summary(start_offset));
1864 let start = position.clone();
1865
1866 cursor.seek_forward(&VersionedFullOffset::Offset(range.end), Bias::Left, &cx);
1867 let mut end_offset = cursor.start().1;
1868 if cursor
1869 .item()
1870 .map_or(false, |fragment| fragment.is_visible(&self.undo_map))
1871 {
1872 end_offset += range.end - cursor.start().0.full_offset();
1873 }
1874 position.add_assign(&rope_cursor.summary(end_offset));
1875 start..position.clone()
1876 })
1877 }
1878
1879 pub fn edits_since_in_range<'a, D>(
1880 &'a self,
1881 since: &'a clock::Global,
1882 range: Range<Anchor>,
1883 ) -> impl 'a + Iterator<Item = Edit<D>>
1884 where
1885 D: TextDimension + Ord,
1886 {
1887 let fragments_cursor = if *since == self.version {
1888 None
1889 } else {
1890 let mut cursor = self
1891 .fragments
1892 .filter(move |summary| !since.observed_all(&summary.max_version));
1893 cursor.next(&None);
1894 Some(cursor)
1895 };
1896 let mut cursor = self
1897 .fragments
1898 .cursor::<(Option<&Locator>, FragmentTextSummary)>();
1899
1900 let start_fragment_id = self.fragment_id_for_anchor(&range.start);
1901 cursor.seek(&Some(start_fragment_id), Bias::Left, &None);
1902 let mut visible_start = cursor.start().1.visible;
1903 let mut deleted_start = cursor.start().1.deleted;
1904 if let Some(fragment) = cursor.item() {
1905 let overshoot = range.start.offset - fragment.insertion_offset;
1906 if fragment.visible {
1907 visible_start += overshoot;
1908 } else {
1909 deleted_start += overshoot;
1910 }
1911 }
1912 let end_fragment_id = self.fragment_id_for_anchor(&range.end);
1913
1914 Edits {
1915 visible_cursor: self.visible_text.cursor(visible_start),
1916 deleted_cursor: self.deleted_text.cursor(deleted_start),
1917 fragments_cursor,
1918 undos: &self.undo_map,
1919 since,
1920 old_end: Default::default(),
1921 new_end: Default::default(),
1922 range: (start_fragment_id, range.start.offset)..(end_fragment_id, range.end.offset),
1923 }
1924 }
1925}
1926
1927struct RopeBuilder<'a> {
1928 old_visible_cursor: rope::Cursor<'a>,
1929 old_deleted_cursor: rope::Cursor<'a>,
1930 new_visible: Rope,
1931 new_deleted: Rope,
1932}
1933
1934impl<'a> RopeBuilder<'a> {
1935 fn new(old_visible_cursor: rope::Cursor<'a>, old_deleted_cursor: rope::Cursor<'a>) -> Self {
1936 Self {
1937 old_visible_cursor,
1938 old_deleted_cursor,
1939 new_visible: Rope::new(),
1940 new_deleted: Rope::new(),
1941 }
1942 }
1943
1944 fn push_tree(&mut self, len: FragmentTextSummary) {
1945 self.push(len.visible, true, true);
1946 self.push(len.deleted, false, false);
1947 }
1948
1949 fn push_fragment(&mut self, fragment: &Fragment, was_visible: bool) {
1950 debug_assert!(fragment.len > 0);
1951 self.push(fragment.len, was_visible, fragment.visible)
1952 }
1953
1954 fn push(&mut self, len: usize, was_visible: bool, is_visible: bool) {
1955 let text = if was_visible {
1956 self.old_visible_cursor
1957 .slice(self.old_visible_cursor.offset() + len)
1958 } else {
1959 self.old_deleted_cursor
1960 .slice(self.old_deleted_cursor.offset() + len)
1961 };
1962 if is_visible {
1963 self.new_visible.append(text);
1964 } else {
1965 self.new_deleted.append(text);
1966 }
1967 }
1968
1969 fn push_str(&mut self, text: &str) {
1970 self.new_visible.push(text);
1971 }
1972
1973 fn finish(mut self) -> (Rope, Rope) {
1974 self.new_visible.append(self.old_visible_cursor.suffix());
1975 self.new_deleted.append(self.old_deleted_cursor.suffix());
1976 (self.new_visible, self.new_deleted)
1977 }
1978}
1979
1980impl<'a, D: TextDimension + Ord, F: FnMut(&FragmentSummary) -> bool> Iterator for Edits<'a, D, F> {
1981 type Item = Edit<D>;
1982
1983 fn next(&mut self) -> Option<Self::Item> {
1984 let mut pending_edit: Option<Edit<D>> = None;
1985 let cursor = self.fragments_cursor.as_mut()?;
1986
1987 while let Some(fragment) = cursor.item() {
1988 if fragment.id < *self.range.start.0 {
1989 cursor.next(&None);
1990 continue;
1991 } else if fragment.id > *self.range.end.0 {
1992 break;
1993 }
1994
1995 if cursor.start().visible > self.visible_cursor.offset() {
1996 let summary = self.visible_cursor.summary(cursor.start().visible);
1997 self.old_end.add_assign(&summary);
1998 self.new_end.add_assign(&summary);
1999 }
2000
2001 if pending_edit
2002 .as_ref()
2003 .map_or(false, |change| change.new.end < self.new_end)
2004 {
2005 break;
2006 }
2007
2008 if !fragment.was_visible(&self.since, &self.undos) && fragment.visible {
2009 let mut visible_end = cursor.end(&None).visible;
2010 if fragment.id == *self.range.end.0 {
2011 visible_end = cmp::min(
2012 visible_end,
2013 cursor.start().visible + (self.range.end.1 - fragment.insertion_offset),
2014 );
2015 }
2016
2017 let fragment_summary = self.visible_cursor.summary(visible_end);
2018 let mut new_end = self.new_end.clone();
2019 new_end.add_assign(&fragment_summary);
2020 if let Some(pending_edit) = pending_edit.as_mut() {
2021 pending_edit.new.end = new_end.clone();
2022 } else {
2023 pending_edit = Some(Edit {
2024 old: self.old_end.clone()..self.old_end.clone(),
2025 new: self.new_end.clone()..new_end.clone(),
2026 });
2027 }
2028
2029 self.new_end = new_end;
2030 } else if fragment.was_visible(&self.since, &self.undos) && !fragment.visible {
2031 let mut deleted_end = cursor.end(&None).deleted;
2032 if fragment.id == *self.range.end.0 {
2033 deleted_end = cmp::min(
2034 deleted_end,
2035 cursor.start().deleted + (self.range.end.1 - fragment.insertion_offset),
2036 );
2037 }
2038
2039 if cursor.start().deleted > self.deleted_cursor.offset() {
2040 self.deleted_cursor.seek_forward(cursor.start().deleted);
2041 }
2042 let fragment_summary = self.deleted_cursor.summary(deleted_end);
2043 let mut old_end = self.old_end.clone();
2044 old_end.add_assign(&fragment_summary);
2045 if let Some(pending_edit) = pending_edit.as_mut() {
2046 pending_edit.old.end = old_end.clone();
2047 } else {
2048 pending_edit = Some(Edit {
2049 old: self.old_end.clone()..old_end.clone(),
2050 new: self.new_end.clone()..self.new_end.clone(),
2051 });
2052 }
2053
2054 self.old_end = old_end;
2055 }
2056
2057 cursor.next(&None);
2058 }
2059
2060 pending_edit
2061 }
2062}
2063
2064impl Fragment {
2065 fn is_visible(&self, undos: &UndoMap) -> bool {
2066 !undos.is_undone(self.insertion_timestamp.local())
2067 && self.deletions.iter().all(|d| undos.is_undone(*d))
2068 }
2069
2070 fn was_visible(&self, version: &clock::Global, undos: &UndoMap) -> bool {
2071 (version.observed(self.insertion_timestamp.local())
2072 && !undos.was_undone(self.insertion_timestamp.local(), version))
2073 && self
2074 .deletions
2075 .iter()
2076 .all(|d| !version.observed(*d) || undos.was_undone(*d, version))
2077 }
2078}
2079
2080impl sum_tree::Item for Fragment {
2081 type Summary = FragmentSummary;
2082
2083 fn summary(&self) -> Self::Summary {
2084 let mut max_version = clock::Global::new();
2085 max_version.observe(self.insertion_timestamp.local());
2086 for deletion in &self.deletions {
2087 max_version.observe(*deletion);
2088 }
2089 max_version.join(&self.max_undos);
2090
2091 let mut min_insertion_version = clock::Global::new();
2092 min_insertion_version.observe(self.insertion_timestamp.local());
2093 let max_insertion_version = min_insertion_version.clone();
2094 if self.visible {
2095 FragmentSummary {
2096 max_id: self.id.clone(),
2097 text: FragmentTextSummary {
2098 visible: self.len,
2099 deleted: 0,
2100 },
2101 max_version,
2102 min_insertion_version,
2103 max_insertion_version,
2104 }
2105 } else {
2106 FragmentSummary {
2107 max_id: self.id.clone(),
2108 text: FragmentTextSummary {
2109 visible: 0,
2110 deleted: self.len,
2111 },
2112 max_version,
2113 min_insertion_version,
2114 max_insertion_version,
2115 }
2116 }
2117 }
2118}
2119
2120impl sum_tree::Summary for FragmentSummary {
2121 type Context = Option<clock::Global>;
2122
2123 fn add_summary(&mut self, other: &Self, _: &Self::Context) {
2124 self.max_id.assign(&other.max_id);
2125 self.text.visible += &other.text.visible;
2126 self.text.deleted += &other.text.deleted;
2127 self.max_version.join(&other.max_version);
2128 self.min_insertion_version
2129 .meet(&other.min_insertion_version);
2130 self.max_insertion_version
2131 .join(&other.max_insertion_version);
2132 }
2133}
2134
2135impl Default for FragmentSummary {
2136 fn default() -> Self {
2137 FragmentSummary {
2138 max_id: Locator::min(),
2139 text: FragmentTextSummary::default(),
2140 max_version: clock::Global::new(),
2141 min_insertion_version: clock::Global::new(),
2142 max_insertion_version: clock::Global::new(),
2143 }
2144 }
2145}
2146
2147impl sum_tree::Item for InsertionFragment {
2148 type Summary = InsertionFragmentKey;
2149
2150 fn summary(&self) -> Self::Summary {
2151 InsertionFragmentKey {
2152 timestamp: self.timestamp,
2153 split_offset: self.split_offset,
2154 }
2155 }
2156}
2157
2158impl sum_tree::KeyedItem for InsertionFragment {
2159 type Key = InsertionFragmentKey;
2160
2161 fn key(&self) -> Self::Key {
2162 sum_tree::Item::summary(self)
2163 }
2164}
2165
2166impl InsertionFragment {
2167 fn new(fragment: &Fragment) -> Self {
2168 Self {
2169 timestamp: fragment.insertion_timestamp.local(),
2170 split_offset: fragment.insertion_offset,
2171 fragment_id: fragment.id.clone(),
2172 }
2173 }
2174
2175 fn insert_new(fragment: &Fragment) -> sum_tree::Edit<Self> {
2176 sum_tree::Edit::Insert(Self::new(fragment))
2177 }
2178}
2179
2180impl sum_tree::Summary for InsertionFragmentKey {
2181 type Context = ();
2182
2183 fn add_summary(&mut self, summary: &Self, _: &()) {
2184 *self = *summary;
2185 }
2186}
2187
2188#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
2189pub struct FullOffset(pub usize);
2190
2191impl ops::AddAssign<usize> for FullOffset {
2192 fn add_assign(&mut self, rhs: usize) {
2193 self.0 += rhs;
2194 }
2195}
2196
2197impl ops::Add<usize> for FullOffset {
2198 type Output = Self;
2199
2200 fn add(mut self, rhs: usize) -> Self::Output {
2201 self += rhs;
2202 self
2203 }
2204}
2205
2206impl ops::Sub for FullOffset {
2207 type Output = usize;
2208
2209 fn sub(self, rhs: Self) -> Self::Output {
2210 self.0 - rhs.0
2211 }
2212}
2213
2214impl<'a> sum_tree::Dimension<'a, FragmentSummary> for usize {
2215 fn add_summary(&mut self, summary: &FragmentSummary, _: &Option<clock::Global>) {
2216 *self += summary.text.visible;
2217 }
2218}
2219
2220impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FullOffset {
2221 fn add_summary(&mut self, summary: &FragmentSummary, _: &Option<clock::Global>) {
2222 self.0 += summary.text.visible + summary.text.deleted;
2223 }
2224}
2225
2226impl<'a> sum_tree::Dimension<'a, FragmentSummary> for Option<&'a Locator> {
2227 fn add_summary(&mut self, summary: &'a FragmentSummary, _: &Option<clock::Global>) {
2228 *self = Some(&summary.max_id);
2229 }
2230}
2231
2232impl<'a> sum_tree::SeekTarget<'a, FragmentSummary, FragmentTextSummary> for usize {
2233 fn cmp(
2234 &self,
2235 cursor_location: &FragmentTextSummary,
2236 _: &Option<clock::Global>,
2237 ) -> cmp::Ordering {
2238 Ord::cmp(self, &cursor_location.visible)
2239 }
2240}
2241
2242#[derive(Copy, Clone, Debug, Eq, PartialEq)]
2243enum VersionedFullOffset {
2244 Offset(FullOffset),
2245 Invalid,
2246}
2247
2248impl VersionedFullOffset {
2249 fn full_offset(&self) -> FullOffset {
2250 if let Self::Offset(position) = self {
2251 *position
2252 } else {
2253 panic!("invalid version")
2254 }
2255 }
2256}
2257
2258impl Default for VersionedFullOffset {
2259 fn default() -> Self {
2260 Self::Offset(Default::default())
2261 }
2262}
2263
2264impl<'a> sum_tree::Dimension<'a, FragmentSummary> for VersionedFullOffset {
2265 fn add_summary(&mut self, summary: &'a FragmentSummary, cx: &Option<clock::Global>) {
2266 if let Self::Offset(offset) = self {
2267 let version = cx.as_ref().unwrap();
2268 if version.observed_all(&summary.max_insertion_version) {
2269 *offset += summary.text.visible + summary.text.deleted;
2270 } else if version.observed_any(&summary.min_insertion_version) {
2271 *self = Self::Invalid;
2272 }
2273 }
2274 }
2275}
2276
2277impl<'a> sum_tree::SeekTarget<'a, FragmentSummary, Self> for VersionedFullOffset {
2278 fn cmp(&self, cursor_position: &Self, _: &Option<clock::Global>) -> cmp::Ordering {
2279 match (self, cursor_position) {
2280 (Self::Offset(a), Self::Offset(b)) => Ord::cmp(a, b),
2281 (Self::Offset(_), Self::Invalid) => cmp::Ordering::Less,
2282 (Self::Invalid, _) => unreachable!(),
2283 }
2284 }
2285}
2286
2287impl Operation {
2288 fn replica_id(&self) -> ReplicaId {
2289 operation_queue::Operation::lamport_timestamp(self).replica_id
2290 }
2291
2292 pub fn local_timestamp(&self) -> clock::Local {
2293 match self {
2294 Operation::Edit(edit) => edit.timestamp.local(),
2295 Operation::Undo { undo, .. } => undo.id,
2296 }
2297 }
2298
2299 pub fn as_edit(&self) -> Option<&EditOperation> {
2300 match self {
2301 Operation::Edit(edit) => Some(edit),
2302 _ => None,
2303 }
2304 }
2305
2306 pub fn is_edit(&self) -> bool {
2307 match self {
2308 Operation::Edit { .. } => true,
2309 _ => false,
2310 }
2311 }
2312}
2313
2314impl operation_queue::Operation for Operation {
2315 fn lamport_timestamp(&self) -> clock::Lamport {
2316 match self {
2317 Operation::Edit(edit) => edit.timestamp.lamport(),
2318 Operation::Undo {
2319 lamport_timestamp, ..
2320 } => *lamport_timestamp,
2321 }
2322 }
2323}
2324
2325pub trait ToOffset {
2326 fn to_offset<'a>(&self, snapshot: &BufferSnapshot) -> usize;
2327}
2328
2329impl ToOffset for Point {
2330 fn to_offset<'a>(&self, snapshot: &BufferSnapshot) -> usize {
2331 snapshot.point_to_offset(*self)
2332 }
2333}
2334
2335impl ToOffset for PointUtf16 {
2336 fn to_offset<'a>(&self, snapshot: &BufferSnapshot) -> usize {
2337 snapshot.point_utf16_to_offset(*self)
2338 }
2339}
2340
2341impl ToOffset for usize {
2342 fn to_offset<'a>(&self, snapshot: &BufferSnapshot) -> usize {
2343 assert!(*self <= snapshot.len(), "offset is out of range");
2344 *self
2345 }
2346}
2347
2348impl ToOffset for Anchor {
2349 fn to_offset<'a>(&self, snapshot: &BufferSnapshot) -> usize {
2350 snapshot.summary_for_anchor(self)
2351 }
2352}
2353
2354impl<'a, T: ToOffset> ToOffset for &'a T {
2355 fn to_offset(&self, content: &BufferSnapshot) -> usize {
2356 (*self).to_offset(content)
2357 }
2358}
2359
2360pub trait ToPoint {
2361 fn to_point<'a>(&self, snapshot: &BufferSnapshot) -> Point;
2362}
2363
2364impl ToPoint for Anchor {
2365 fn to_point<'a>(&self, snapshot: &BufferSnapshot) -> Point {
2366 snapshot.summary_for_anchor(self)
2367 }
2368}
2369
2370impl ToPoint for usize {
2371 fn to_point<'a>(&self, snapshot: &BufferSnapshot) -> Point {
2372 snapshot.offset_to_point(*self)
2373 }
2374}
2375
2376impl ToPoint for PointUtf16 {
2377 fn to_point<'a>(&self, snapshot: &BufferSnapshot) -> Point {
2378 snapshot.point_utf16_to_point(*self)
2379 }
2380}
2381
2382impl ToPoint for Point {
2383 fn to_point<'a>(&self, _: &BufferSnapshot) -> Point {
2384 *self
2385 }
2386}
2387
2388pub trait ToPointUtf16 {
2389 fn to_point_utf16<'a>(&self, snapshot: &BufferSnapshot) -> PointUtf16;
2390}
2391
2392impl ToPointUtf16 for Anchor {
2393 fn to_point_utf16<'a>(&self, snapshot: &BufferSnapshot) -> PointUtf16 {
2394 snapshot.summary_for_anchor(self)
2395 }
2396}
2397
2398impl ToPointUtf16 for usize {
2399 fn to_point_utf16<'a>(&self, snapshot: &BufferSnapshot) -> PointUtf16 {
2400 snapshot.offset_to_point_utf16(*self)
2401 }
2402}
2403
2404impl ToPointUtf16 for PointUtf16 {
2405 fn to_point_utf16<'a>(&self, _: &BufferSnapshot) -> PointUtf16 {
2406 *self
2407 }
2408}
2409
2410impl ToPointUtf16 for Point {
2411 fn to_point_utf16<'a>(&self, snapshot: &BufferSnapshot) -> PointUtf16 {
2412 snapshot.point_to_point_utf16(*self)
2413 }
2414}
2415
2416pub trait Clip {
2417 fn clip(&self, bias: Bias, snapshot: &BufferSnapshot) -> Self;
2418}
2419
2420impl Clip for usize {
2421 fn clip(&self, bias: Bias, snapshot: &BufferSnapshot) -> Self {
2422 snapshot.clip_offset(*self, bias)
2423 }
2424}
2425
2426impl Clip for Point {
2427 fn clip(&self, bias: Bias, snapshot: &BufferSnapshot) -> Self {
2428 snapshot.clip_point(*self, bias)
2429 }
2430}
2431
2432impl Clip for PointUtf16 {
2433 fn clip(&self, bias: Bias, snapshot: &BufferSnapshot) -> Self {
2434 snapshot.clip_point_utf16(*self, bias)
2435 }
2436}
2437
2438pub trait FromAnchor {
2439 fn from_anchor(anchor: &Anchor, snapshot: &BufferSnapshot) -> Self;
2440}
2441
2442impl FromAnchor for Point {
2443 fn from_anchor(anchor: &Anchor, snapshot: &BufferSnapshot) -> Self {
2444 snapshot.summary_for_anchor(anchor)
2445 }
2446}
2447
2448impl FromAnchor for PointUtf16 {
2449 fn from_anchor(anchor: &Anchor, snapshot: &BufferSnapshot) -> Self {
2450 snapshot.summary_for_anchor(anchor)
2451 }
2452}
2453
2454impl FromAnchor for usize {
2455 fn from_anchor(anchor: &Anchor, snapshot: &BufferSnapshot) -> Self {
2456 snapshot.summary_for_anchor(anchor)
2457 }
2458}