Struct Txn 

pub struct Txn<'a> { /* private fields */ }

A set of edits that lands as one undo group.

Dropping a transaction without committing rolls it back: the buffer returns to the text, cursor and selection it had when the transaction opened. That is cheap for the same reason the history is — restoring a text is restoring a handle — and it means a panic part-way through a compound edit cannot leave half of one behind.

Implementations

impl<'a> Txn<'a>

pub fn text(&self) -> &Text

The text as it stands part-way through the transaction.

pub fn cursor(&self) -> Position

pub fn selection(&self) -> Option<Span>

pub fn map(&self, position: Position) -> Option<Position>

Carry a position made earlier in — or before — this transaction forward to where it now points.

None when the position belongs to neither this transaction nor the state it opened from. Text inserted exactly at the position is left in front of it, so a marker keeps pointing at what it was pointing at; text deleted across it collapses it to the start of what was removed.

pub fn insert(&mut self, at: Position, text: &str) -> bool

Insert text at at.

Returns false, changing nothing, when at belongs to neither this transaction nor the state it opened from.

pub fn delete(&mut self, span: Span) -> bool

Remove the text in span.

pub fn replace(&mut self, span: Span, text: &str) -> bool

Replace the text in span with text.

Deleting and inserting as one primitive, so the pair cannot be recorded as two undo steps and cannot be interrupted between them.

pub fn set_cursor(&mut self, to: Position) -> bool

Move the cursor, dropping any selection. Not itself an edit.

pub fn select(&mut self, span: Span) -> bool

Select span, leaving the cursor at its end.

For a compound edit that must leave a selection behind — wrapping a selection in brackets leaves the inner text selected, so the next wrap nests.

pub fn clear_selection(&mut self)

pub fn commit(self) -> Option<Change>

Record the transaction and report what it did.

None when nothing changed: no history entry, no revision, nothing for a consumer to re-derive. A transaction that only moved the cursor keeps the move — cursor position is not history.

Trait Implementations

impl Drop for Txn<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.