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