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