Struct Delta 

pub struct Delta {
    pub ops: Vec<Op>,
}

A per-field edit against a base content. Ops apply left-to-right, consuming base positions; Retain/Delete advance the base cursor, Insert adds new text. USV throughout.

Serializes as { "ops": [ {"retain": n} | {"insert": s} | {"delete": n} ] }: plain, structured-clone-able data an editor bridge stores in a change record and maps its own positions through (map_pos). The serde shape is the wire the rebase codec and applyChange bundle carry across the language bindings.

Deliberately not #[non_exhaustive], unlike the model types. The attribute buys exactly one freedom, adding a field, and this type cannot spend it: {ops} is the wire, so a second field is a wire change every binding’s codec has to learn either way.

Fields

ops: Vec<Op>

Implementations

impl Delta

pub fn expected_base_len(&self) -> usize

Chars of base the Retain/Delete ops together consume: the base length this delta was built against.

pub fn apply(&self, base: &str) -> String

Apply to base, producing the new text. Base beyond what the ops consume is retained implicitly: a short delta names only the region it changes (a bare prepend, an edit near the start) and the untouched remainder carries through. Panics if the ops consume more base than exists (expected_base_len() > base.chars().count()): a delta built against a longer revision. This is the trusted-provenance path; clamping an over-long delta silently is corruption, so where the base’s provenance isn’t already trusted use Self::try_apply, which returns the mismatch as an error instead.

pub fn try_apply(&self, base: &str) -> Result<String, BaseLengthMismatch>

Self::apply, but returns BaseLengthMismatch instead of panicking when the ops consume more base than base has: a delta built against a longer revision. Implicit trailing retain is the contract: a short delta (ops consuming less than base) is accepted and the untouched remainder is retained, matching map_pos’s implicit trailing retain so a producer that names only the changed region need not pad a bare trailing Op::Retain.

Cost of the leniency: a short delta carries no full-base-length check, so one replayed against a wrong but longer base applies silently instead of failing. An abbreviated delta forfeits that tripwire by construction; over-consumption still fails.

pub fn map_pos(&self, pos: usize, assoc: Assoc) -> usize

Map a base char position to its new position. assoc decides the side of a same-position insertion (After moves past it).

Trait Implementations

impl Clone for Delta

fn clone(&self) -> Delta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Delta

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Delta

fn deserialize<__D>( __deserializer: __D, ) -> Result<Delta, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Delta

impl PartialEq for Delta

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Delta

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Delta