Struct similar::algorithms::Replace

pub struct Replace<D: DiffHook> { /* private fields */ }

A DiffHook that combines deletions and insertions to give blocks of maximal length, and replacements when appropriate.

It will replace DiffHook::insert and DiffHook::delete events when possible with DiffHook::replace events. Note that even though the text processing in the crate does not use replace events and always resolves then back to delete and insert, it’s useful to always use the replacer to ensure a consistent order of inserts and deletes. This is why for instance the text diffing automatically uses this hook internally.

Implementations

impl<D: DiffHook> Replace<D>

pub fn new(d: D) -> Self

Creates a new replace hook wrapping another hook.

pub fn into_inner(self) -> D

Extracts the inner hook.

Trait Implementations

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

fn as_mut(&mut self) -> &mut D

Converts this type into a mutable reference of the (usually inferred) input type.

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

fn as_ref(&self) -> &D

Converts this type into a shared reference of the (usually inferred) input type.

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

type Error = <D as DiffHook>::Error

The error produced from the hook methods.

fn equal(
    &mut self,
    old_index: usize,
    new_index: usize,
    len: usize
) -> Result<(), D::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<(), D::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<(), D::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<(), D::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.

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

Always called at the end of the algorithm.