Struct Dmp

pub struct Dmp {
    pub text1: String,
    pub text2: String,
    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

text1: String

text2: String

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_from_delta(&mut self, text1: &str, delta: &str) -> Vec<Diff>

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