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