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