Trait DiffHook

pub trait DiffHook: Sized {
    type Error;

    // Provided methods
    fn equal(
        &mut self,
        old_index: usize,
        new_index: usize,
        len: usize,
    ) -> Result<(), Self::Error> { ... }
    fn delete(
        &mut self,
        old_index: usize,
        old_len: usize,
        new_index: usize,
    ) -> Result<(), Self::Error> { ... }
    fn insert(
        &mut self,
        old_index: usize,
        new_index: usize,
        new_len: usize,
    ) -> Result<(), Self::Error> { ... }
    fn replace(
        &mut self,
        old_index: usize,
        old_len: usize,
        new_index: usize,
        new_len: usize,
    ) -> Result<(), Self::Error> { ... }
    fn finish(&mut self) -> Result<(), Self::Error> { ... }
}

A trait for reacting to an edit script from the “old” version to the “new” version.

Required Associated Types

type Error

The error produced from the hook methods.

Provided Methods

fn equal( &mut self, old_index: usize, new_index: usize, len: usize, ) -> Result<(), Self::Error>

Called when lines with indices old_index (in the old version) and new_index (in the new version) start an section equal in both versions, of length len.

fn delete( &mut self, old_index: usize, old_len: usize, new_index: usize, ) -> Result<(), Self::Error>

Called when a section of length old_len, starting at old_index, needs to be deleted from the old version.

fn insert( &mut self, old_index: usize, new_index: usize, new_len: usize, ) -> Result<(), Self::Error>

Called when a section of the new version, of length new_len and starting at new_index, needs to be inserted at position `old_index’.

fn replace( &mut self, old_index: usize, old_len: usize, new_index: usize, new_len: usize, ) -> Result<(), Self::Error>

Called when a section of the old version, starting at index old_index and of length old_len, needs to be replaced with a section of length new_len, starting at new_index, of the new version.

The default implementations invokes delete and insert.

You can use the Replace hook to automatically generate these.

fn finish(&mut self) -> Result<(), Self::Error>

Always called at the end of the algorithm.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, D: DiffHook + 'a> DiffHook for &'a mut D

type Error = <D as DiffHook>::Error

fn equal( &mut self, old_index: usize, new_index: usize, len: usize, ) -> Result<(), Self::Error>

fn delete( &mut self, old_index: usize, old_len: usize, new_index: usize, ) -> Result<(), Self::Error>

fn insert( &mut self, old_index: usize, new_index: usize, new_len: usize, ) -> Result<(), Self::Error>

fn replace( &mut self, old: usize, old_len: usize, new: usize, new_len: usize, ) -> Result<(), Self::Error>

fn finish(&mut self) -> Result<(), Self::Error>

Implementors

impl DiffHook for Capture

type Error = Infallible

impl<'old, 'new, Old, New, D> DiffHook for Compact<'old, 'new, Old, New, D>

where D: DiffHook, Old: Index<usize> + ?Sized + 'old, New: Index<usize> + ?Sized + 'new, New::Output: PartialEq<Old::Output>,

type Error = <D as DiffHook>::Error

impl<D: DiffHook> DiffHook for NoFinishHook<D>

type Error = <D as DiffHook>::Error

impl<D: DiffHook> DiffHook for Replace<D>

type Error = <D as DiffHook>::Error