Struct Edit 

pub struct Edit {
    pub range: Range,
    pub kind: EditKind,
}

A single buffer mutation: replace the bytes in Self::range with the text carried by Self::kind.

Coordinates are pre-edit Positions (line + UTF-8 byte). A compound change is a sequence of Edits applied in order — each against the buffer as the previous one left it — and grouped into one undo step by the dispatcher.

Examples

use lattice_protocol::{Edit, EditKind, Position, Range};

// Insert "fn " at the start of line 3: an empty range plus text.
let insert = Edit::insert(Position::new(3, 0), "fn ");
assert!(insert.range.is_empty());

// Delete bytes 4..7 of line 0: a range plus empty text.
let delete = Edit::delete(Range::new(Position::new(0, 4), Position::new(0, 7)));
let EditKind::Replace { text } = &delete.kind;
assert!(text.is_empty());

// Replace is the general form both of the above reduce to.
let word = Range::new(Position::new(1, 0), Position::new(1, 5));
assert_eq!(Edit::replace(word, "world").range, word);

Fields

range: Range

The half-open span to replace, in pre-edit coordinates. Empty for an insert.

kind: EditKind

What to put there.

Implementations

impl Edit

pub fn insert(at: Position, text: impl Into<String>) -> Self

Insert text at at (an empty-range replace).

pub fn delete(range: Range) -> Self

Delete the bytes in range (a replace with empty text).

pub fn replace(range: Range, text: impl Into<String>) -> Self

Replace the bytes in range with text.

Trait Implementations

impl Clone for Edit

fn clone(&self) -> Edit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Edit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Edit

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Edit

impl PartialEq for Edit

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Edit

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Edit