Enum similar::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

old_index: usize

The starting index in the old sequence.

new_index: usize

The starting index in the new sequence.

len: usize

The length of the segment.

Delete

A segment was deleted (see DiffHook::delete)

Fields

old_index: usize

The starting index in the old sequence.

old_len: usize

The length of the old segment.

new_index: usize

The starting index in the new sequence.

Insert

A segment was inserted (see DiffHook::insert)

Fields

old_index: usize

The starting index in the old sequence.

new_index: usize

The starting index in the new sequence.

new_len: usize

The length of the new segment.

Replace

A segment was replaced (see DiffHook::replace)

Fields

old_index: usize

The starting index in the old sequence.

old_len: usize

The length of the old segment.

new_index: usize

The starting index in the new sequence.

new_len: usize

The length of the new segment.

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.

pub fn iter_changes<'lookup, Old, New, T>( &self, old: &'lookup Old, new: &'lookup New ) -> ChangesIter<'lookup, Old, New, T>

where Old: Index<usize, Output = T> + ?Sized, New: Index<usize, Output = T> + ?Sized,

Iterates over all changes encoded in the diff op against old and new sequences.

old and new are two indexable objects like the types you pass to the diffing algorithm functions.

use similar::{ChangeTag, Algorithm};
use similar::capture_diff_slices;
let old = vec!["foo", "bar", "baz"];
let new = vec!["foo", "bar", "blah"];
let ops = capture_diff_slices(Algorithm::Myers, &old, &new);
let changes: Vec<_> = ops
    .iter()
    .flat_map(|x| x.iter_changes(&old, &new))
    .map(|x| (x.tag(), x.value()))
    .collect();
assert_eq!(changes, vec![
    (ChangeTag::Equal, "foo"),
    (ChangeTag::Equal, "bar"),
    (ChangeTag::Delete, "baz"),
    (ChangeTag::Insert, "blah"),
]);

pub fn iter_slices<'lookup, Old, New, T>( &self, old: &'lookup Old, new: &'lookup New ) -> impl Iterator<Item = (ChangeTag, &'lookup T)>

where T: 'lookup + ?Sized, Old: Index<Range<usize>, Output = T> + ?Sized, New: Index<Range<usize>, Output = T> + ?Sized,

Given a diffop yields the changes it encodes against the given slices.

This is similar to DiffOp::iter_changes but instead of yielding the individual changes it yields consequitive changed slices.

This will only ever yield a single tuple or two tuples in case a DiffOp::Replace operation is passed.

use similar::{ChangeTag, Algorithm};
use similar::capture_diff_slices;
let old = vec!["foo", "bar", "baz"];
let new = vec!["foo", "bar", "blah"];
let ops = capture_diff_slices(Algorithm::Myers, &old, &new);
let changes: Vec<_> = ops.iter().flat_map(|x| x.iter_slices(&old, &new)).collect();
assert_eq!(changes, vec![
    (ChangeTag::Equal, &["foo", "bar"][..]),
    (ChangeTag::Delete, &["baz"][..]),
    (ChangeTag::Insert, &["blah"][..]),
]);

Due to lifetime restrictions it’s currently impossible for the returned slices to outlive the lookup.

Trait Implementations

impl Clone for DiffOp

fn clone(&self) -> DiffOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DiffOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DiffOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for DiffOp

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq 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: &Rhs) -> bool

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

impl Serialize for DiffOp

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DiffOp

impl Eq for DiffOp

impl StructuralPartialEq for DiffOp