Enum TextEdit 

pub enum TextEdit {
    Insertion {
        at: Offset,
        text: String,
    },
    Deletion {
        start: Offset,
        end: Offset,
    },
}

One text change: the text a buffer gains at a point, or the stretch it loses.

An edit acts on both halves of the indexing relation — on source text through Self::apply and on a Span through Span::shifted — and those two actions are designed to agree.

An insertion carries the text it inserts rather than a pair of boundaries, because the boundaries are recoverable (at and at + text.len()) while the text is not, and without the text an edit cannot act on a buffer at all.

Variants

Insertion

Inserts text at one byte boundary.

Fields

at: Offset

The insertion boundary.

text: String

The inserted text.

Deletion

Deletes one half-open byte range.

Fields

start: Offset

The first deleted byte.

end: Offset

The boundary after the last deleted byte.

Implementations

impl TextEdit

pub fn insertion(at: Offset, text: impl Into<String>) -> Self

Creates an insertion of text landing at at.

pub fn deletion(start: Offset, end: Offset) -> Self

Creates a deletion of the text occupying start..end.

Panics

Panics when start is greater than end.

Examples found in repository

examples/live_parser.rs (line 137)

fn main() -> io::Result<()> {
    let interactive = io::stdin().is_terminal() && io::stdout().is_terminal();
    let _terminal = TerminalMode::raw();
    let mut bytes = Vec::new();
    let mut parser = NativeRealtimeParser::new("");
    let mut stdout = io::stdout().lock();

    if interactive {
        stdout.write_all(render(&parser, true).as_bytes())?;
        stdout.flush()?;
    }

    for byte in io::stdin().lock().bytes() {
        let byte = byte?;
        match byte {
            3 | 4 => break,
            8 | 127 => {
                if let Ok(source) = std::str::from_utf8(&bytes)
                    && let Some((index, _)) = source.char_indices().next_back()
                {
                    bytes.truncate(index);
                }
            }
            b'\r' => bytes.push(b'\n'),
            byte => bytes.push(byte),
        }
        let Ok(source) = std::str::from_utf8(&bytes) else {
            continue;
        };
        if let Some(appended) = source.strip_prefix(parser.source()) {
            parser.append(appended);
        } else if parser.source().starts_with(source) {
            parser
                .apply_edit(&TextEdit::deletion(source.len(), parser.source().len()))
                .expect("backspace always removes a valid source suffix");
        } else {
            parser = NativeRealtimeParser::new(source);
        }
        if interactive {
            stdout.write_all(render(&parser, true).as_bytes())?;
            stdout.flush()?;
        }
    }

    if !interactive {
        let source = String::from_utf8(bytes)
            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
        debug_assert_eq!(source, parser.source());
        stdout.write_all(render(&parser, false).as_bytes())?;
    }
    Ok(())
}

pub fn apply(&self, source: &str) -> Option<String>

Returns source with this edit applied, or None when the edit falls outside the buffer or across a character boundary.

Trait Implementations

impl Clone for TextEdit

fn clone(&self) -> TextEdit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TextEdit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for TextEdit

impl PartialEq for TextEdit

fn eq(&self, other: &TextEdit) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for TextEdit