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