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