+ bencher.iter(|| dmp.diff_main_compat(&old, &new).unwrap());

+use crate::{errors::Error, DType};

+pub struct Diff<T: DType>(Ops, Vec<T>);

+impl Display for Diff<char> {

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

+ write!(

+ f,

+ "({:?}, {})",

+ self.op(),

+ self.data().iter().collect::<String>()

+ )

+ }

+}

+

+impl<T: DType> Diff<T> {

+ /// enable/ disable `compatibility mode`

+ /// If you are preparing `patches` that need to be compatible across other `diff-match-patch` libraries enable `compatibility` mode

+ /// Compatibility mode adds some extra overhead of preparing diffs cohereant with `char` representation instead of bytes

+ /// defaults to `false`

+ compat_mode: bool,

+ /// The number of bits in an int.

+ match_max_bits: usize,

+ compat_mode: false,

+struct HalfMatch<'a, T: DType> {

+ pub(crate) fn diff_internal<'a, T: DType>(

+ old_bytes: &'a [T],

+ new_bytes: &'a [T],

+ ) -> Result<Vec<Diff<T>>, crate::errors::Error> {

+ fn compute<'a, T: DType>(

+ old: &'a [T],

+ new: &'a [T],

+ ) -> Result<Vec<Diff<T>>, crate::errors::Error> {

+ fn half_match<'a, T: DType>(

+ fn line_mode<'a, T: DType>(

+ old: &'a [T],

+ new: &'a [T],

+ ) -> Result<Vec<Diff<T>>, crate::errors::Error> {

+ pub fn bisect<'a, T: DType>(

+ fn half_match_i<'a, T: DType>(

+ fn common_prefix<T: DType>(lhs: &[T], rhs: &[T], reverse: bool) -> usize {

+ fn common_overlap<T: DType>(lhs: &[T], rhs: &[T]) -> usize {

+ fn cleanup_semantic<T: DType>(diffs: &mut Vec<Diff<T>>) {

+ fn cleanup_semantic_lossless<T: DType>(diffs: &mut Vec<Diff<T>>) {

+ fn cleanup_semantic_score<T: DType>(one: &[T], two: &[T]) -> u8 {

+ let (char1, char2) = if let (Some(&char1), Some(&char2)) = (one.last(), two.first()) && let (Some(c1), Some(c2)) = (char1.as_char(), char2.as_char()) {

+ (c1, c2)

+ let blankline_1 = linebreak_1 && T::is_linebreak_end(one);

+ let blankline_2 = linebreak_2 && T::is_linebreak_start(two);

+ fn cleanup_merge<T: DType>(diffs: &mut Vec<Diff<T>>) {

+ fn x_index<T: DType>(diffs: &[Diff<T>], loc: usize) -> usize {

+struct LineToChars<'a, T: DType> {

+ lines: Vec<&'a [T]>,

+ fn lines_to_chars<'a, T: DType>(old: &'a [T], new: &'a [T]) -> LineToChars<'a, T> {

+ let mut lines: Vec<&'a [T]> = vec![];

+ let mut linehash: HashMap<&'a [T], usize> = HashMap::new();

+ fn lines_to_chars_internal<'a, T: DType>(

+ text: &'a [T],

+ array: &mut Vec<&'a [T]>,

+ hash: &mut HashMap<&'a [T], usize>,

+ text.split_inclusive(|u| *u == T::from_char('\n'))

+ fn chars_to_lines<T: DType>(diffs: &[Diff<usize>], lines: &[&[T]]) -> Vec<Diff<T>> {

+ pub fn diff_main_compat(&self, old: &str, new: &str) -> Result<Vec<Diff<char>>, crate::errors::Error> {

+ let (old, new) = (

+ char::from_str(old),

+ char::from_str(new)

+ );

+

+ self.diff_internal(

+ &old[..],

+ &new[..],

+ self.checklines(),

+ self.deadline(),

+ )

+ }

+

+

+

+#![feature(trait_alias, let_chains)]

+

+pub(crate) use traits::DType;

+use std::hash::Hash;

+

+

+pub trait DType: Copy + Ord + Eq + Hash {

+

+ fn from_char(c: char) -> Self;

+

+ fn as_char(&self) -> Option<char>;

+

+ fn from_str(str: &str) -> Vec<Self>;

+

+ fn is_linebreak_end(input: &[Self]) -> bool;

+ fn is_linebreak_start(input: &[Self]) -> bool;

+impl DType for u8 {

+

+ fn from_char(c: char) -> Self {

+ c as u8

+ }

+

+ fn as_char(&self) -> Option<char> {

+ Some(*self as char)

+ }

+

+ fn from_str(str: &str) -> Vec<Self> {

+ str.as_bytes().to_vec()

+ }

+

+ #[inline]

+ fn is_linebreak_end(input: &[Self]) -> bool {

+ input.ends_with(b"\n\n") || input.ends_with(b"\n\r\n")

+ }

+

+ #[inline]

+ fn is_linebreak_start(input: &[Self]) -> bool {

+ input.starts_with(b"\r\n\n")

+ || input.starts_with(b"\r\n\r\n")

+ || input.starts_with(b"\n\r\n")

+ || input.starts_with(b"\n\n")

+ }

+}

+

+impl DType for char {

+ fn bisect_split(

+ dmp: &DiffMatchPatch,

+ old: &[char],

+ new: &[char],

+ x: usize,

+ y: usize,

+ deadline: Option<NaiveTime>,

+ ) -> Result<Vec<Diff<char>>, crate::errors::Error> {

+ let old_a = &old[..x];

+ let new_a = &new[..y];

+

+ let old_b = &old[x..];

+ let new_b = &new[y..];

+

+ // Compute both diffs serially.

+ let mut diffs_a = dmp.diff_internal(old_a, new_a, false, deadline)?;

+ diffs_a.append(&mut dmp.diff_internal(old_b, new_b, false, deadline)?);

+

+ Ok(diffs_a)

+ }

+

+ fn from_char(c: char) -> Self {

+ c

+ }

+

+ fn as_char(&self) -> Option<char> {

+ Some(*self)

+ }

+

+ fn from_str(str: &str) -> Vec<Self> {

+ str.chars().collect::<Vec<_>>()

+ }

+

+ #[inline]

+ fn is_linebreak_end(input: &[Self]) -> bool {

+ input.ends_with(&['\n', '\n']) || input.ends_with(&['\n', '\r', '\n'])

+ }

+

+ #[inline]

+ fn is_linebreak_start(input: &[Self]) -> bool {

+ input.starts_with(&['\r', '\n', '\n'])

+ || input.starts_with(&['\r', '\n', '\r', '\n'])

+ || input.starts_with(&['\n', '\r', '\n'])

+ || input.starts_with(&['\n', '\n'])

+ }

+impl DType for usize {

+

+ fn from_char(c: char) -> Self {

+ (c as u8) as usize

+ }

+

+ fn as_char(&self) -> Option<char> {

+ char::from_digit(*self as u32, 10)

+ }

+

+ fn from_str(_: &str) -> Vec<Self> {

+ unimplemented!()

+ }

+

+ fn is_linebreak_end(_: &[Self]) -> bool {

+ unimplemented!()

+ }

+

+ #[inline]

+ fn is_linebreak_start(_: &[Self]) -> bool {

+ unimplemented!()

+ }

+} \ No newline at end of file

+fn test_diff_main_compat() -> Result<(), Error> {

+ let mut dmp = DiffMatchPatch::default();

+

+ // Perform a trivial diff.

+ // Null case.

+ assert!(dmp.diff_main_compat("", "")?.is_empty());

+

+ // Equality

+ // assert_eq!(vec![Diff::equal(b"abc")], dmp.diff_main_compat("abc", "abc")?);

+

+ // // Simple insert

+ // assert_eq!(

+ // vec![Diff::equal(b"ab"), Diff::insert(b"123"), Diff::equal(b"c")],

+ // dmp.diff_main_compat("abc", "ab123c")?

+ // );

+

+ // // Simple delete

+ // assert_eq!(

+ // vec![Diff::equal(b"a"), Diff::delete(b"123"), Diff::equal(b"bc")],

+ // dmp.diff_main_compat("a123bc", "abc")?

+ // );

+

+ // // Two insertions

+ // assert_eq!(

+ // vec![

+ // Diff::equal(b"a"),

+ // Diff::insert(b"123"),

+ // Diff::equal(b"b"),

+ // Diff::insert(b"456"),

+ // Diff::equal(b"c"),

+ // ],

+ // dmp.diff_main_compat("abc", "a123b456c")?

+ // );

+

+ // // Two deletions.

+ // assert_eq!(

+ // vec![

+ // Diff::equal(b"a"),

+ // Diff::delete(b"123"),

+ // Diff::equal(b"b"),

+ // Diff::delete(b"456"),

+ // Diff::equal(b"c"),

+ // ],

+ // dmp.diff_main_compat("a123b456c", "abc")?

+ // );

+

+ // // Perform a real diff.

+ // // Switch off the timeout.

+ // dmp.set_timeout(None);

+ // // Simple cases.

+ // assert_eq!(

+ // vec![Diff::delete(b"a"), Diff::insert(b"b"),],

+ // dmp.diff_main_compat("a", "b")?

+ // );

+

+ // assert_eq!(

+ // vec![

+ // Diff::delete(b"Apple"),

+ // Diff::insert(b"Banana"),

+ // Diff::equal(b"s are a"),

+ // Diff::insert(b"lso"),

+ // Diff::equal(b" fruit.")

+ // ],

+ // dmp.diff_main_compat("Apples are a fruit.", "Bananas are also fruit.")?

+ // );

+

+ // assert_eq!(

+ // vec![

+ // Diff::delete(b"a"),

+ // Diff::insert("\u{0680}".as_bytes()),

+ // Diff::equal(b"x"),

+ // Diff::delete(b"\t"),

+ // Diff::insert(b"\0")

+ // ],

+ // dmp.diff_main_compat("ax\t", "\u{0680}x\0")?

+ // );

+

+ // // Overlaps.

+ // assert_eq!(

+ // vec![

+ // Diff::delete(b"1"),

+ // Diff::equal(b"a"),

+ // Diff::delete(b"y"),

+ // Diff::equal(b"b"),

+ // Diff::delete(b"2"),

+ // Diff::insert(b"xab"),

+ // ],

+ // dmp.diff_main_compat("1ayb2", "abxab")?

+ // );

+

+ // assert_eq!(

+ // vec![

+ // Diff::insert(b"xaxcx"),

+ // Diff::equal(b"abc"),

+ // Diff::delete(b"y"),

+ // ],

+ // dmp.diff_main_compat("abcy", "xaxcxabc")?

+ // );

+

+ // assert_eq!(

+ // vec![

+ // Diff::delete(b"ABCD"),

+ // Diff::equal(b"a"),

+ // Diff::delete(b"="),

+ // Diff::insert(b"-"),

+ // Diff::equal(b"bcd"),

+ // Diff::delete(b"="),

+ // Diff::insert(b"-"),

+ // Diff::equal(b"efghijklmnopqrs"),

+ // Diff::delete(b"EFGHIJKLMNOefg"),

+ // ],

+ // dmp.diff_main_compat(

+ // "ABCDa=bcd=efghijklmnopqrsEFGHIJKLMNOefg",

+ // "a-bcd-efghijklmnopqrs"

+ // )?

+ // );

+

+ // Large equality.

+ assert_eq!(

+ vec![

+ Diff::insert(&[' ']),

+ Diff::equal(&['a']),

+ Diff::insert(&['n','d']),

+ Diff::equal(&[' ','[','[','H','e','p','a','t','o','p','a','n','c','r','e','a','t','i','c',']',']']),

+ Diff::delete(&" and [[New".chars().collect::<Vec<_>>()[..]),

+ ],

+ dmp.diff_main_compat(

+ "a [[Hepatopancreatic]] and [[New",

+ " and [[Hepatopancreatic]]"

+ )?

+ );

+

+ // Timeout.

+ const LOW_TIMEOUT: u32 = 100;

+ dmp.set_timeout(Some(LOW_TIMEOUT));

+ let a = vec!["`Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe.\n"; 2048].join("");

+ let b = vec!["I am the very model of a modern major general,\nI\'ve information vegetable, animal, and mineral,\nI know the kings of England, and I quote the fights historical,\nFrom Marathon to Waterloo, in order categorical.\n"; 2048].join("");

+

+ let start = Utc::now().time();

+ dmp.diff_main(&a, &b)?;

+ let end = Utc::now().time();

+ // Test that we took at least the timeout period (+ 5ms being generous).

+ assert!((end - start).num_milliseconds() <= LOW_TIMEOUT as i64 + 5);

+

+ // Test the linemode speedup.

+ // Must be long to pass the 100 char cutoff.

+ // Simple line-mode.

+ dmp.set_timeout(Some(1000));

+ let a = "12345678901234567890123456789 0123456 78901234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";

+ let b = "abcdefghij abcdefghij abcdefghij abcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\nabcdefghij\n";

+ dmp.set_checklines(false);

+ let res_no_lm = dmp.diff_main(a, b)?;

+ dmp.set_checklines(true);

+ let res_yes_lm = dmp.diff_main(a, b)?;

+

+ // Now, we'll run 2 checks - one for result equality

+ assert_eq!(res_no_lm, res_yes_lm);

+

+ // Single line-mode.

+ let a = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";

+ let b = "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij";

+ dmp.set_checklines(false);

+ let yes_lm = dmp.diff_main(a, b)?;

+ dmp.set_checklines(true);

+ let no_lm = dmp.diff_main(a, b)?;

+ assert_eq!(no_lm, yes_lm);

+

+ // Overlap line-mode.

+ let a = "1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n1234567890\n";

+ let b = "abcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n1234567890\n1234567890\n1234567890\nabcdefghij\n";

+ dmp.set_checklines(false);

+ let no_lm = dmp.diff_main(a, b)?;

+ dmp.set_checklines(true);

+ let yes_lm = dmp.diff_main(a, b)?;

+ assert_eq!(rebuild_text(&yes_lm[..])?, rebuild_text(&no_lm[..])?);

+

+ // Benefits of checklines can only be realized in text with many lines

+ let mut dmp = DiffMatchPatch::default();

+ let old = std::fs::read_to_string("testdata/txt_old.txt").unwrap();

+ let new = std::fs::read_to_string("testdata/txt_new.txt").unwrap();

+

+ let start = Instant::now();

+ let diff_yes_lm = dmp.diff_main(&old, &new);

+ let yes_lm_dur = Instant::now() - start;

+ assert!(diff_yes_lm.is_ok());

+

+ dmp.set_checklines(false);

+ let start = Instant::now();

+ let diff_no_lm = dmp.diff_main(&old, &new);

+ let no_lm_dur = Instant::now() - start;

+ assert!(diff_no_lm.is_ok());

+

+ assert!(no_lm_dur > yes_lm_dur);

+

+ Ok(())

+}

+

+#[test]