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