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