use std::{char, collections::HashMap, fmt::Display};

use chrono::{NaiveTime, TimeDelta, Utc};

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

/// Enum representing the different ops of diff

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

pub enum Ops {

}

}

let mut data = diffs

.iter()

.map(|diff| {

match diff.op() {

Ops::Insert => {

// format!("+{encoded}")

}

Ops::Delete => {

}

Ops::Equal => {

}

}

})

}

#[inline]

diffs

.iter()

.filter_map(|diff| {

}

diffs

.iter()

.filter_map(|diff| {

// limit of the match algorithm.

// Intended to be called only from within patch_apply.

#[inline]

let max_bit = self.match_max_bits();

let patch_margin = self.patch_margin() as usize;

// Match methods

impl DiffMatchPatch {

// Check for null inputs.

// Nothing to match.

if text.is_empty() {

}

}

if pattern.len() > self.match_max_bits() {

todo!("Throw error");

}

best_loc

}

let mut map = HashMap::with_capacity(pattern.len());

pattern.iter().enumerate().for_each(|(i, &p)| {

}

// Patch Methods

start1: usize,

start2: usize,

length1: usize,

length2: usize,

}

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

let coord1 = if self.length1 == 0 {

format!("{},0", self.start1)

coord2,

" @@\n".to_string(),

];

let sign = match diff.op() {

Ops::Insert => '+',

Ops::Delete => '-',

Ops::Equal => ' ',

};

segments.push(segment)

write!(f, "{}", segments.join(""))

}

}

&self.diffs[..]

}

}

Texts(&'a str, &'a str),

}

impl DiffMatchPatch {

let mut section = Vec::with_capacity(64);

let mut current_sect = 0;

let mut new_cols = None;

for &c in s.iter() {

match current_sect {

0 => {

return None;

}

}

return None;

}

let ol = splits.first()?;

if let Some(&oc) = splits.get(1) {

}

}

2 => {

.collect::<Vec<_>>();

let nl = splits.first()?;

if let Some(&nc) = splits.get(1) {

}

}

_ => {

continue;

}

return None;

}

section.push(c);

}

return None;

}

Some((old_line, old_cols, new_line, new_cols))

}

&self,

// No diffs -> no patches

if diffs.is_empty() {

return Ok(Vec::new());

let mut char_n1 = 0;

let mut char_n2 = 0;

diffs.iter().enumerate().for_each(|(idx, diff)| {

// a new patch starts here

Ok(patches)

}

if text.is_empty() {

return;

}

patch.length2 += prefix.len() + suffix.len();

}

&self,

if patches.is_empty() {

return Ok((source.to_vec(), vec![]));

}

Ok((source, results))

}

let pad_len = self.patch_margin() as usize;

let null_pad = (1..pad_len + 1)

.collect::<Vec<_>>();

// Bump all the patches forward.

/// Given a diff, measure its Levenshtein distance in terms of the number of inserted, deleted or substituted characters.

/// The minimum distance is 0 which means equality, the maximum distance is the length of the longer string.

let mut levenshtein = 0;

let mut insert = 0;

let mut delete = 0;

/// Given two texts, or an already computed list of differences, return an array of patch objects.

/// The third form PatchInput::TextDiffs(...) is preferred, use it if you happen to have that data available, otherwise this function will compute the missing pieces.

/// TODO: add example

let mut diff_input;

let txt_old;

let (txt, diffs) = match input {

// No diffs provided, lets make our own

PatchInput::Texts(txt1, txt2) => {

if diff_input.len() > 2 {

Self::cleanup_semantic(&mut diff_input);

}

}

PatchInput::Diffs(diffs) => {

// No origin string provided, compute our own.

}

};

}

/// Reduces an array of patch objects to a block of text which looks extremely similar to the standard GNU diff/patch format. This text may be stored or transmitted.

/// TODO: add example

patches.iter().map(|p| p.to_string()).collect::<String>()

}

/// Parses a block of text (which was presumably created by the patch_toText function) and returns an array of patch objects.

/// TODO: add example

if text.is_empty() {

return Ok(vec![]);

}

let mut patches = vec![];

};

// Should never panic, already checked for `empty`

}

text.remove(0);

/// If patch_delete_threshold is closer to 1, then the deleted text may contain anything.

/// In most use cases Patch_DeleteThreshold should just be set to the same value as match_threshold.

/// TODO: add example

&self,

source_txt: &str,

) -> Result<(String, Vec<bool>), crate::errors::Error> {

Ok((

results,

))

}

use std::hash::Hash;

use chrono::NaiveTime;

use crate::dmp::{Diff, DiffMatchPatch};

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

fn bisect_split(

dmp: &DiffMatchPatch,

old: &[Self],

) -> Result<Vec<Diff<Self>>, crate::errors::Error>;

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 bisect_split(

dmp: &DiffMatchPatch,

old: &[u8],

}

#[inline]

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

input.ends_with(b"\n\n") || input.ends_with(b"\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],

}

#[inline]

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

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

}

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

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

}

}

impl DType for usize {

fn bisect_split(

dmp: &DiffMatchPatch,

old: &[usize],

unimplemented!()

}

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

unimplemented!()

}

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

unimplemented!()

}

} \ No newline at end of file

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

// Equality

// Large equality.

assert_eq!(