Enum similar::algorithms::DiffOp

pub enum DiffOp {
    Equal {
        old_index: usize,
        new_index: usize,
        len: usize,
    },
    Delete {
        old_index: usize,
        old_len: usize,
        new_index: usize,
    },
    Insert {
        old_index: usize,
        new_index: usize,
        new_len: usize,
    },
    Replace {
        old_index: usize,
        old_len: usize,
        new_index: usize,
        new_len: usize,
    },
}

Utility enum to capture a diff operation.

This is used by Capture.

Variants

Equal

A segment is equal (see DiffHook::equal)

Fields of Equal

old_index: usizenew_index: usizelen: usize

Delete

A segment was deleted (see DiffHook::delete)

Fields of Delete

old_index: usizeold_len: usizenew_index: usize

Insert

A segment was inserted (see DiffHook::insert)

Fields of Insert

old_index: usizenew_index: usizenew_len: usize

Replace

A segment was replaced (see DiffHook::replace)

Fields of Replace

old_index: usizeold_len: usizenew_index: usizenew_len: usize

Implementations

impl DiffOp

pub fn tag(self) -> DiffTag

Returns the tag of the operation.

pub fn old_range(&self) -> Range<usize>

Returns the old range.

pub fn new_range(&self) -> Range<usize>

Returns the new range.

pub fn as_tag_tuple(&self) -> (DiffTag, Range<usize>, Range<usize>)

Transform the op into a tuple of diff tag and ranges.

This is useful when operating on slices. The returned format is (tag, i1..i2, j1..j2):

• Replace: a[i1..i2] should be replaced by b[j1..j2]
• Delete: a[i1..i2] should be deleted (j1 == j2 in this case).
• Insert: b[j1..j2] should be inserted at a[i1..i2] (i1 == i2 in this case).
• Equal: a[i1..i2] is equal to b[j1..j2].

pub fn apply_to_hook<D: DiffHook>(&self, d: &mut D) -> Result<(), D::Error>

Apply this operation to a diff hook.

Trait Implementations

impl Clone for DiffOp

fn clone(&self) -> DiffOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for DiffOp

impl Debug for DiffOp

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

Formats the value using the given formatter.

impl Eq for DiffOp

impl Hash for DiffOp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<DiffOp> for DiffOp

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for DiffOp

impl StructuralPartialEq for DiffOp