Struct EditedText 

pub struct EditedText<'a, T>
where
    T: PartialEq + Clone + Debug,
{ /* private fields */ }

A text document with a sequence of operations derived from diffing it against an updated version. Supports merging two EditedText instances (from the same original) via Operational Transformation.

Created via from_strings, from_strings_with_tokenizer, or from_diff, then merged with another EditedText and applied to get the reconciled text.

Also tracks cursor positions from the updated text, repositioning them when operations are applied.

Implementations

impl<'a> EditedText<'a, String>

pub fn from_strings(original: &'a str, updated: &TextWithCursors) -> Self

Create an EditedText from the given original and updated strings. Uses the default word tokenizer (splits on word boundaries).

impl<'a, T> EditedText<'a, T>

where T: PartialEq + Clone + Debug,

pub fn from_strings_with_tokenizer( original: &'a str, updated: &TextWithCursors, tokenizer: &Tokenizer<T>, ) -> Self

Create an EditedText from the given original and updated strings using the provided tokenizer

pub fn merge(self, other: Self) -> Self

Merge two EditedText instances. The two instances must be derived from the same original text. The operations are merged using the principles of Operational Transformation. The cursors are updated accordingly to reflect the changes made by the merged operations.

Panics

Panics if there’s an integer overflow (in isize) when calculating new cursor positions.

pub fn apply(&self) -> TextWithCursors

Apply the operations to the text and return the resulting text

pub fn apply_with_history(&self) -> Vec<SpanWithHistory>

Apply the operations to the text and return the resulting text in chunks together with the provenance describing where each chunk came from.

Returns all spans including deletions (not present in the merged text).

 use reconcile_text::{History, SpanWithHistory, BuiltinTokenizer, reconcile};

 let parent = "Merging text is hard!";
 let left = "Merging text is easy!"; // Changed "hard" to "easy"
 let right = "With reconcile, merging documents is hard!"; // Added prefix and changed word

 let result = reconcile(
     parent,
     &left.into(),
     &right.into(),
     &*BuiltinTokenizer::Word,
 );

 assert_eq!(
     result.apply_with_history(),
     vec![
         SpanWithHistory::new("Merging text".to_string(), History::RemovedFromRight,),
         SpanWithHistory::new(
             "With reconcile, merging documents".to_string(),
             History::AddedFromRight,
         ),
         SpanWithHistory::new(" ".to_string(), History::Unchanged,),
         SpanWithHistory::new("is".to_string(), History::Unchanged,),
         SpanWithHistory::new(" hard!".to_string(), History::RemovedFromLeft,),
         SpanWithHistory::new(" easy!".to_string(), History::AddedFromLeft,),
     ]
 );

pub fn apply_with_all(&self) -> (TextWithCursors, Vec<SpanWithHistory>)

Apply the operations and return both the merged text with cursors and the provenance history in a single pass

pub fn to_diff(&self) -> Result<Vec<NumberOrText>, DiffError>

Convert the EditedText into a terse representation ready for serialization. The result omits cursor positions and the original text. This is useful for sending text diffs over the network if there’s a clear consensus on the original text.

Inserts are strings, deletes are negative integers (character count), and retained spans are positive integers (character count).

Errors

Returns DiffError::IntegerOverflow if a character count exceeds i64::MAX.

pub fn from_diff( original_text: &'a str, diff: Vec<NumberOrText>, tokenizer: &Tokenizer<T>, ) -> Result<EditedText<'a, T>, DiffError>

Reconstruct an EditedText from a diff and the original text.

Errors

Returns DiffError::LengthExceedsOriginal if the diff references a range that exceeds the original text length.

Panics

Panics if there’s an integer overflow in i64.

Trait Implementations

impl<'a, T> Clone for EditedText<'a, T>

where T: PartialEq + Clone + Debug + Clone,

fn clone(&self) -> EditedText<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Debug for EditedText<'a, T>

where T: PartialEq + Clone + Debug + Debug,

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

Formats the value using the given formatter.

impl<'a, T> Default for EditedText<'a, T>

where T: PartialEq + Clone + Debug + Default,

fn default() -> EditedText<'a, T>

Returns the “default value” for a type.

impl<'a, T> PartialEq for EditedText<'a, T>

where T: PartialEq + Clone + Debug + PartialEq,

fn eq(&self, other: &EditedText<'a, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T> StructuralPartialEq for EditedText<'a, T>

where T: PartialEq + Clone + Debug,