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