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