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