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