add base

lib/search_and_replace/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "search_and_replace"
+version = "0.1.0"
+edition = "2021"
+
+[profile.release]
+strip = true
+
+[dependencies]

lib/search_and_replace/src/main.rs

@@ -0,0 +1,371 @@
+use std::{env::args, io::Read};
+
+#[derive(Debug, PartialEq)]
+struct JumpTable {
+    jumps: Vec<usize>,
+}
+
+impl JumpTable {
+    fn resolve_char(
+        pat: &Vec<char>,
+        ptr: &usize,
+        cur_char: &char,
+    ) -> usize {
+        if pat.get(*ptr).unwrap() == cur_char {
+            return *ptr + 1;
+        }
+        if pat.get(0).unwrap() == cur_char {
+            return 1;
+        }
+        return 0;
+    }
+
+    pub fn new(pat: &Vec<char>) -> Self {
+        if pat.len() == 0 {
+            return Self { jumps: vec![] };
+        }
+        let mut ptr = 0_usize;
+        let mut jumps = vec![0];
+        for cur_char in pat.iter().skip(1) {
+            ptr = JumpTable::resolve_char(pat, &ptr, cur_char);
+            jumps.push(ptr);
+        }
+
+        Self { jumps }
+    }
+
+    pub fn search(&self, pat: &Vec<char>, needle: &char, ptr: &usize) -> usize {
+        let mut ptr = *ptr;
+        while ptr != 0 {
+            if pat.get(ptr).unwrap() == needle {
+                break;
+            }
+            ptr = *self.jumps.get(ptr.saturating_sub(1)).unwrap();
+        }
+        ptr
+    }
+}
+
+#[derive(Debug, PartialEq)]
+struct Pattern {
+    pat: Vec<char>,
+    jt: JumpTable,
+    ptr: usize,
+}
+
+impl Pattern {
+    pub fn new(pat: String) -> Result<Self, ()> {
+        if pat.len() == 0 {
+            return Err(());
+        }
+        let pat = pat.chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        Ok(Self {
+            pat,
+            jt,
+            ptr: 0,
+        })
+    }
+
+    pub fn search_and_update(&mut self, cur_char: &char) -> bool {
+        if self.pat.get(self.ptr).unwrap() == cur_char {
+            self.ptr += 1;
+            return if self.ptr == self.pat.len() { true } else { false };
+        }
+        let found = self.jt.search(&self.pat, &cur_char, &self.ptr);
+        self.ptr = found;
+        false
+    }
+
+    pub fn reset_ptr(&mut self) {
+        self.ptr = 0;
+    }
+
+    pub fn len(&self) -> usize {
+        self.pat.len()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct Match {
+    pub pat_id: usize,
+    pub start_pos: usize,
+    pub len: usize,
+}
+
+impl Match {
+    pub fn new(pat_id: usize, start_pos: usize, len: usize) -> Self {
+        Self { pat_id, start_pos, len }
+    }
+}
+
+#[derive(Debug)]
+struct MPSearch {
+    pats: Vec<Pattern>,
+}
+
+impl MPSearch {
+    pub fn new(pats: Vec<Pattern>) -> Self {
+        Self { pats }
+    }
+
+    fn reset_all_ptrs(&mut self) {
+        for pat in self.pats.iter_mut() {
+            pat.reset_ptr();
+        }
+    }
+
+    fn search_at_pos(&mut self, cur_char: &char, pos: &usize) -> Option<Match> {
+        let mut cur_match = None;
+        for (idx, pat) in self.pats.iter_mut().enumerate() {
+            if pat.search_and_update(cur_char) {
+                cur_match = Some(Match::new(idx, pos.saturating_sub(pat.len() - 1), pat.len()));
+                break;
+            }
+        }
+        if let Some(_) = cur_match {
+            self.reset_all_ptrs();
+        }
+        cur_match
+    }
+
+    pub fn search(&mut self, haystack: &String) -> Vec<Match> {
+        let mut res = Vec::new();
+        for (cur_idx, cur_char) in haystack.chars().enumerate() {
+            if let Some(cur_match) = self.search_at_pos(&cur_char, &cur_idx) {
+                res.push(cur_match);
+            }
+        }
+        res
+    }
+}
+
+macro_rules! skip_n {
+    ($iter: ident, $n: expr) => {
+        for _ in 0..$n {
+            $iter.next().ok_or(())?;
+        }
+    }
+}
+
+macro_rules! append_n {
+    ($iter: ident, $target: ident, $n: expr) => {
+        for _ in 0..$n {
+            $target.push($iter.next().ok_or(())?);
+        }
+    }
+}
+
+
+#[derive(Debug)]
+struct MPReplace {
+    replacements: Vec<String>,
+    matches: Vec<Match>,
+}
+
+impl MPReplace {
+    pub fn new(matches: Vec<Match>, replacements: Vec<String>) -> Self {
+        Self { replacements, matches }
+    }
+
+    pub fn replace(&self, target: &String) -> Result<String, ()> {
+        let mut ptr = 0;
+        let mut iter = target.chars();
+        let mut res = String::new();
+        for cur_match in self.matches.iter() {
+            append_n!(iter, res, cur_match.start_pos - ptr);
+            skip_n!(iter, cur_match.len);
+            res.push_str(self.replacements.get(cur_match.pat_id).ok_or(())?);
+            ptr = cur_match.start_pos + cur_match.len;
+        }
+        append_n!(iter, res, target.chars().count() - ptr);
+        Ok(res)
+    }
+}
+
+struct PatMatchArgs<I: Iterator<Item = String>> {
+    inner: I,
+}
+
+impl<I: Iterator<Item = String>> PatMatchArgs<I> {
+    pub fn new(inner: I, count: usize) -> Result<Self, ()> {
+        if count % 2 != 0 {
+            return Err(());
+        }
+        Ok(Self { inner })
+    }
+}
+
+impl<I: Iterator<Item = String>> Iterator for PatMatchArgs<I> {
+    type Item = (String, String);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some((self.inner.next()?, self.inner.next()?))
+    }
+}
+
+fn main() {
+    let mut contents = Vec::new();
+    std::io::stdin().lock().read_to_end(&mut contents).unwrap();
+    let contents = std::str::from_utf8(&contents).unwrap().to_string();
+
+    let args = match PatMatchArgs::new(args().skip(1), args().len() - 1) {
+        Ok(val) => val,
+        Err(()) => {
+            eprintln!("the number of arguments after filepath must be divisible by two");
+            std::process::exit(1);
+        }
+    };
+    let mut pats = Vec::new();
+    let mut replacements = Vec::new();
+    for (cur_pat, cur_replacement) in args {
+        let Ok(cur_pat) = Pattern::new(cur_pat) else {
+            eprintln!("the patterns can't be empty");
+            std::process::exit(1);
+        };
+        pats.push(cur_pat);
+        replacements.push(cur_replacement);
+    }
+
+    let matches = MPSearch::new(pats).search(&contents);
+    let replaced = MPReplace::new(matches, replacements)
+        .replace(&contents).unwrap();
+    println!("{}", replaced);
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{JumpTable, MPReplace, MPSearch, Match, Pattern};
+
+    #[test]
+    fn jumps_01() {
+        let src = String::from("thisthen").chars().collect::<Vec<_>>();
+        let target = vec![0_usize, 0, 0, 0, 1, 2, 0, 0];
+        let jt = JumpTable::new(&src);
+        assert_eq!(jt.jumps, target);
+    }
+
+    #[test]
+    fn jumps_02() {
+        let src = String::from("tthis").chars().collect::<Vec<_>>();
+        let target = vec![0, 1, 0, 0, 0];
+        let jt = JumpTable::new(&src);
+        assert_eq!(jt.jumps, target);
+    }
+
+    #[test]
+    fn jumps_03() {
+        let src = String::from("t").chars().collect::<Vec<_>>();
+        let target = vec![0];
+        let jt = JumpTable::new(&src);
+        assert_eq!(jt.jumps, target);
+    }
+
+    #[test]
+    fn jumps_04() {
+        let src = String::from("tt").chars().collect::<Vec<_>>();
+        let target = vec![0, 1];
+        let jt = JumpTable::new(&src);
+        assert_eq!(jt.jumps, target);
+    }
+
+    #[test]
+    fn jumps_05() {
+        let src = String::from("").chars().collect::<Vec<_>>();
+        let target = vec![];
+        let jt = JumpTable::new(&src);
+        assert_eq!(jt.jumps, target);
+    }
+
+    #[test]
+    fn search_01() {
+        let pat = String::from("tthis").chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        assert_eq!(jt.search(&pat, &'t', &1), 1);
+    }
+
+    #[test]
+    fn search_02() {
+        let pat = String::from("testtesa").chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        assert_eq!(jt.search(&pat, &'t', &7), 3);
+    }
+
+    #[test]
+    fn search_03() {
+        let pat = String::from("ahojahoj").chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        assert_eq!(jt.search(&pat, &'j', &7), 7);
+    }
+
+    #[test]
+    fn search_04() {
+        let pat = String::from("ahojahoj").chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        assert_eq!(jt.search(&pat, &'j', &7), 7);
+    }
+
+    #[test]
+    fn search_05() {
+        let pat = String::from("jojojojojojoja").chars().collect::<Vec<_>>();
+        let jt = JumpTable::new(&pat);
+        assert_eq!(jt.search(&pat, &'o', &13), 11);
+    }
+
+    #[test]
+    fn search_and_update_01() {
+        let pat = String::from("test");
+        let mut pat = Pattern::new(pat).unwrap();
+        let haystack = String::from("thisisatest");
+        for cur_haystack in haystack.chars().take(haystack.len() - 1) {
+            assert_eq!(pat.search_and_update(&cur_haystack), false);
+            println!("{:?}", pat);
+        }
+        println!("{:?}", pat);
+        assert_eq!(pat.search_and_update(&'t'), true);
+    }
+
+    #[test]
+    fn empty_pattern() {
+        assert_eq!(Pattern::new("".chars().collect()), Err(()));
+    }
+
+    #[test]
+    fn mpsearch_01() {
+        let mut mpsearch = MPSearch::new(
+            vec!["this", "is", "a", "test"]
+                .iter()
+                .map(|p| Pattern::new(p.to_string()).unwrap())
+                .collect()
+        );
+        println!("{:?}", mpsearch);
+        let haystack = String::from("this is a test");
+        let target = vec![
+            Match::new(0, 0, 4),
+            Match::new(1, 5, 2),
+            Match::new(2, 8, 1),
+            Match::new(3, 10, 4)
+        ];
+        assert_eq!(mpsearch.search(&haystack), target);
+    }
+
+    #[test]
+    fn mpreplace_01() {
+        let mut mpsearch = MPSearch::new(
+            vec!["this", "is", "a", "test"]
+                .iter()
+                .map(|p| Pattern::new(p.to_string()).unwrap())
+                .collect()
+        );
+        let haystack = String::from("this-is.a*test///");
+        let matches = mpsearch.search(&haystack);
+        let mpreplace = MPReplace::new(matches, vec![
+            "that".to_string(),
+            "isn't".to_string(),
+            "the".to_string(),
+            "final".to_string(),
+        ]);
+        let replaced = mpreplace.replace(&haystack).unwrap();
+        assert_eq!(replaced, "that-isn't.the*final///");
+    }
+}