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