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