Allow Reading From Multiple Input Files

config.toml

 auth = "12345"
-term_frequency_threshold = 2
+term_frequency_threshold = 1
 max_predict_count = 5
 blocked_words = ""
\ No newline at end of file

src/main.rs

@@ -38,10 +38,9 @@ fn main() -> Result<(), io::Error> {
         }
     }
 
-    let markov_chain = basic_set::from_file_path_and_config("../../data/data.csv",config.clone())
-        .unwrap_or(basic_set::from_file_path_and_config("data/data.csv",config.clone())
-            .unwrap_or(basic_set::from_file_path_and_config("data.csv",config.clone())
-                .unwrap_or(basic_set::SetPredictor::new())));
+    let markov_chain = basic_markov::from_file_path_and_config(
+        vec!["../../data/data.csv","data/data.csv","data.csv"],config.clone())
+                .unwrap_or(basic_markov::MarkovChainPredictor::new());
 
 
     // let term_frequency_threshold = match config.get("term_frequency_threshold") {

src/predictors/basic_markov.rs

@@ -116,20 +116,32 @@ pub fn from_file_path(file_path: &str) -> Result<MarkovChainPredictor, std::io::
 }
 
 
-pub fn from_file_path_and_config(file_path: &str, config: HashMap<String, impl Into<String>>) -> Result<MarkovChainPredictor, std::io::Error> {
+pub fn from_file_path_and_config(file_paths: Vec<&str>, config: HashMap<String, impl Into<String>>) -> Result<MarkovChainPredictor, std::io::Error> {
     let mut configuration = HashMap::new();
     for (key, value) in config {
         configuration.insert(key, value.into());
     }
-    let file = File::open(file_path)?;
-    let mut reader = ReaderBuilder::new().from_reader(file);
+
     let mut markov_chain: MarkovChainPredictor = MarkovChainPredictor::new();
     markov_chain.configuration = configuration;
 
-    for result in reader.records() {
-        let record = result?;
-        if let Some(query) = record.get(5) {
-            markov_chain.update(query);
+    for path in file_paths {
+        println!("Trying to open data file at {}",path);
+        match File::open(path) {
+            Ok(file) => {
+                println!("Reading data file...");
+                let mut reader = ReaderBuilder::new().from_reader(file);
+
+                for result in reader.records() {
+                    let record = result?;
+                    if let Some(query) = record.get(5) {
+                        markov_chain.update(query);
+                    }
+                }
+            },
+            Err(e) => {
+                println!("Error while reading: {}",e);
+            }
         }
     }
 

src/predictors/basic_set.rs

-use std::{collections::HashMap, fs::File};
+use std::{collections::HashMap, f32::consts::E, fs::File};
 
 use csv::ReaderBuilder;
 
@@ -104,22 +104,32 @@ pub fn from_file_path(file_path: &str) -> Result<SetPredictor, std::io::Error> {
 }
 
 
-pub fn from_file_path_and_config(file_path: &str, config: HashMap<String, impl Into<String>>) -> Result<SetPredictor, std::io::Error> {
+pub fn from_file_path_and_config(file_paths: Vec<&str>, config: HashMap<String, impl Into<String>>) -> Result<SetPredictor, std::io::Error> {
     let mut configuration = HashMap::new();
     for (key, value) in config {
         configuration.insert(key, value.into());
     }
-    println!("Trying to open data file at {}",file_path);
-    let file = File::open(file_path)?;
-    println!("Reading data file...");
-    let mut reader = ReaderBuilder::new().from_reader(file);
+
     let mut markov_chain: SetPredictor = SetPredictor::new();
     markov_chain.configuration = configuration;
 
-    for result in reader.records() {
-        let record = result?;
-        if let Some(query) = record.get(5) {
-            markov_chain.update(query);
+    for path in file_paths {
+        println!("Trying to open data file at {}",path);
+        match File::open(path) {
+            Ok(file) => {
+                println!("Reading data file...");
+                let mut reader = ReaderBuilder::new().from_reader(file);
+
+                for result in reader.records() {
+                    let record = result?;
+                    if let Some(query) = record.get(5) {
+                        markov_chain.update(query);
+                    }
+                }
+            },
+            Err(e) => {
+                println!("Error while reading: {}",e);
+            }
         }
     }