added least common sequence and levenshtein with no substitution

examples/searcher.rs

@@ -0,0 +1,96 @@
+extern crate levtree;
+
+use levtree::{CaseInsensitiveKeyChecker, CaseSensitiveKeyChecker};
+use levtree::{
+    DamerauLevenshteinDistanceCalculator, DistanceCalculator, KeyChecker, LcsDistanceCalculator,
+    LevTrie, LevenshteinDistanceCalculator, LevenshteinNoSubDistanceCalculator,
+};
+
+use std::io::BufRead;
+use std::io::BufReader;
+
+use clap::{Parser, ValueEnum};
+
+#[derive(Debug, Clone, ValueEnum)]
+enum Algorithm {
+    Lcs,
+    Levenshtein,
+    LevenshteinNoSub,
+    DamerauLevenshtein,
+}
+
+/// Encrypt/decrypt files using catenaccio cipher
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+struct CliArgs {
+    /// Word to look up
+    #[arg(short, long)]
+    wordkey: String,
+
+    /// Number of results returned
+    #[arg(short, long, default_value_t = 10)]
+    result_size: usize,
+
+    //Specify distance algorithm
+    #[arg(short, long, required = false, default_value = "damerau-levenshtein")]
+    distance: Algorithm,
+
+    //Toggle case sensitivity
+    #[arg(short, long, required = false, default_value_t = false)]
+    case_sensitive: bool,
+}
+
+impl CliArgs {}
+
+fn run<KC: KeyChecker<char>, DC: DistanceCalculator<char, KC>>(args: &CliArgs) {
+    let mut trie = LevTrie::<char, KC>::new();
+    let bytes = include_bytes!("words.txt");
+    let reader = BufReader::new(&bytes[..]);
+    reader
+        .lines()
+        .map(|line| line.unwrap())
+        .for_each(|word: String| {
+            trie.add(word.chars());
+        });
+    let word = args.wordkey.chars().collect::<Vec<char>>();
+    let results = trie.fuzzy_search::<DC>(&word, args.result_size);
+    for result in results {
+        let word: String = trie.lineal_descendant(result.word).into_iter().collect();
+        println!("distance: {}, wordkey: {}", result.distance, word);
+    }
+}
+
+fn main() {
+    let args = CliArgs::parse();
+    if args.case_sensitive {
+        match args.distance {
+            Algorithm::Lcs => {
+                run::<CaseSensitiveKeyChecker, LcsDistanceCalculator>(&args);
+            }
+            Algorithm::Levenshtein => {
+                run::<CaseSensitiveKeyChecker, LevenshteinDistanceCalculator>(&args);
+            }
+            Algorithm::LevenshteinNoSub => {
+                run::<CaseSensitiveKeyChecker, LevenshteinNoSubDistanceCalculator>(&args);
+            }
+            Algorithm::DamerauLevenshtein => {
+                run::<CaseSensitiveKeyChecker, DamerauLevenshteinDistanceCalculator>(&args);
+            }
+        }
+    } else {
+        match args.distance {
+            Algorithm::Lcs => {
+                run::<CaseInsensitiveKeyChecker, LcsDistanceCalculator>(&args);
+            }
+            Algorithm::Levenshtein => {
+                run::<CaseInsensitiveKeyChecker, LevenshteinDistanceCalculator>(&args);
+            }
+            Algorithm::LevenshteinNoSub => {
+                run::<CaseInsensitiveKeyChecker, LevenshteinNoSubDistanceCalculator>(&args);
+            }
+            Algorithm::DamerauLevenshtein => {
+                run::<CaseInsensitiveKeyChecker, DamerauLevenshteinDistanceCalculator>(&args);
+            }
+        }
+    }
+}