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