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