Struct dmp::Dmp

pub struct Dmp {
    pub diff_timeout: Option<f32>,
    pub edit_cost: i32,
    pub match_distance: i32,
    pub patch_margin: i32,
    pub match_maxbits: i32,
    pub match_threshold: f32,
    pub patch_delete_threshold: f32,
}

Fields

diff_timeout: Option<f32>

edit_cost: i32

match_distance: i32

patch_margin: i32

match_maxbits: i32

match_threshold: f32

patch_delete_threshold: f32

Implementations

impl Dmp

pub fn new() -> Self

pub fn diff_main(
    &mut self,
    text1: &str,
    text2: &str,
    checklines: bool
) -> Vec<Diff>

pub fn diff_linemode(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> Vec<Diff>

pub fn diff_bisect(&mut self, char1: &Vec<char>, char2: &Vec<char>) -> Vec<Diff>

pub fn diff_words_tochars(
    &mut self,
    text1: &String,
    text2: &String
) -> (String, String, Vec<String>)

pub fn diff_words_tochars_munge(
    &mut self,
    text: &String,
    wordarray: &mut Vec<String>,
    wordhash: &mut HashMap<String, u32>
) -> String

pub fn diff_lines_tochars(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> (String, String, Vec<String>)

pub fn diff_lines_tochars_munge(
    &mut self,
    text: &Vec<char>,
    linearray: &mut Vec<String>,
    linehash: &mut HashMap<String, i32>
) -> String

pub fn diff_chars_tolines(
    &mut self,
    diffs: &mut Vec<Diff>,
    line_array: &Vec<String>
)

pub fn diff_common_prefix(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> i32

pub fn diff_common_suffix(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> i32

pub fn diff_common_overlap(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> i32

pub fn split_by_char(&mut self, text: &str, ch: char) -> Vec<String>

pub fn split_by_chars(&mut self, text: &str) -> Vec<String>

pub fn diff_half_match(
    &mut self,
    text1: &Vec<char>,
    text2: &Vec<char>
) -> Vec<String>

pub fn diff_cleanup_semantic(&mut self, diffs: &mut Vec<Diff>)

pub fn diff_cleanup_semantic_lossless(&mut self, diffs: &mut Vec<Diff>)

pub fn diff_cleanup_efficiency(&mut self, diffs: &mut Vec<Diff>)

pub fn diff_cleanup_merge(&mut self, diffs: &mut Vec<Diff>)

pub fn diff_xindex(&mut self, diffs: &Vec<Diff>, loc: i32) -> i32

pub fn diff_text1(&mut self, diffs: &mut Vec<Diff>) -> String

pub fn diff_text2(&mut self, diffs: &mut Vec<Diff>) -> String

pub fn diff_levenshtein(&mut self, diffs: &Vec<Diff>) -> i32

pub fn diff_todelta(&mut self, diffs: &mut Vec<Diff>) -> String

pub fn diff_todelta_unit(
    &mut self,
    diffs: &mut Vec<Diff>,
    length_unit: LengthUnit
) -> String

pub fn match_main(&mut self, text1: &str, patern1: &str, loc: i32) -> i32

pub fn match_bitap(
    &mut self,
    text: &Vec<char>,
    patern: &Vec<char>,
    loc: i32
) -> i32

pub fn match_bitap_score(
    &mut self,
    e: i32,
    x: i32,
    loc: i32,
    patern: &Vec<char>
) -> f32

pub fn match_alphabet(&mut self, patern: &Vec<char>) -> HashMap<char, i32>

pub fn patch_add_context(&mut self, patch: &mut Patch, text: &mut Vec<char>)

pub fn patch_make1(&mut self, text1: &str, text2: &str) -> Vec<Patch>

pub fn patch_make2(&mut self, diffs: &mut Vec<Diff>) -> Vec<Patch>

pub fn patch_make3(
    &mut self,
    text1: &str,
    _text2: &str,
    diffs: &mut Vec<Diff>
) -> Vec<Patch>

pub fn patch_make4(&mut self, text1: &str, diffs: &mut Vec<Diff>) -> Vec<Patch>

pub fn patch_deep_copy(&mut self, patches: &mut Vec<Patch>) -> Vec<Patch>

pub fn patch_apply(
    &mut self,
    patches: &mut Vec<Patch>,
    source_text: &str
) -> (Vec<char>, Vec<bool>)

pub fn patch_add_padding(&mut self, patches: &mut Vec<Patch>) -> Vec<char>

pub fn patch_splitmax(&mut self, patches: &mut Vec<Patch>)

pub fn patch_to_text(&mut self, patches: &mut Vec<Patch>) -> String

pub fn patch_from_text(&mut self, textline: String) -> Vec<Patch>

pub fn patch1_from_text(&mut self, textline: String) -> Patch