Functionality implemented

src/main.rs

@@ -21,11 +21,19 @@ fn main() {
 
     myparser.prompt();
 
+    println!("\nDumping files");
     let rawvalues = myparser.filedump();
+    // myparser.print_values(&rawvalues);
 
-    let parsed_values = myparser.updatevalues(rawvalues);
-    myparser.removedups(&parsed_values);
+    println!("\nUpdating values");
+    let parsed_values = myparser.updatevalues(&rawvalues);
 
-    myparser.print_values(&parsed_values);
-    myparser.save_file(parsed_values);
+    println!("\nRemoving duplicates");
+    let newupdated = myparser.removedups(&parsed_values);
+
+    println!("\nPrinting values");
+    myparser.print_values(&newupdated);
+
+    println!("\nSaving file");
+    let _result = myparser.save_file(parsed_values);
 }

src/parser.rs

@@ -2,7 +2,15 @@
 pub mod parser {
     use std::fs::File;
     use std::io::{self, BufRead, BufReader};
+    use std::collections::HashSet;
 
+    // use serde::{Serialize, Deserialize};
+    use serde::Serialize;
+    use serde::Deserialize;
+    // use std::fs::File;
+    use std::io::prelude::*;
+
+    #[derive(Clone, Deserialize, Serialize)]
     pub struct SomeObject {
         pub value: String
     }
@@ -27,7 +35,11 @@ pub mod parser {
                             value: phonenumber
                         };
 
-                        objs.push(myobj);
+
+                        if !myobj.value.is_empty() {
+                            // println!("{}", myobj.value);
+                            objs.push(myobj);
+                        }
                     }
                 }
             }
@@ -35,14 +47,73 @@ pub mod parser {
             return objs;
         }
 
-        pub fn updatevalues(&self, vals: Vec<SomeObject>) -> Vec<SomeObject> {
-            let mut updated: Vec<SomeObject> = vals;
+        pub fn updatevalues(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
+            let mut updated: Vec<SomeObject> = Vec::new();
+
+            let mut remove_chars: Vec<char> = Vec::new();
+            remove_chars.push(')');
+            remove_chars.push('(');
+            remove_chars.push(' ');
+            remove_chars.push('-');
+
+            let mut i: i32 = 0;
+
+            // let prefix: String = String::from("+1");
+
+            for a in vals {
+                println!("Iter {}", i);
+
+                let mut parsed: String = a.value.clone();
+                if a.value.len() < 2 {
+                    println!("{} is an invalid number", a.value);
+                    continue;
+                }
+
+                let mut pars = self.remove_some_data(&parsed, &remove_chars);
+                parsed.clear();
+                parsed = pars;
+
+                println!("{}", parsed.clone());
+
+                let updated_parsed = self.add_prefix(parsed);
+
+                let myobj: SomeObject = SomeObject {
+                    value: updated_parsed.clone()
+                };
+
+                updated.push(myobj);
+                i = i + 1;
+            }
+
 
             return updated;
         }
 
-        pub fn removedups(&self, vals: &Vec<SomeObject>) {
+        pub fn removedups(&self, mut vals: &Vec<SomeObject>) -> Vec<SomeObject> {
             println!("Hi");
+            // let mut tmp: Vec<String> = Vec::new();
+            let mut tmp: HashSet<String> = HashSet::new();
+            //v.retain(|e| set.insert(e.clone()));
+            let mut mm: Vec<SomeObject> = Vec::new();
+            mm = vals.clone();
+            mm.retain(|e| tmp.insert(e.value.clone()));
+
+            // vals.clear();
+            // vals.clear();
+            let mut updated: Vec<SomeObject> = Vec::new();
+
+            for t in tmp {
+                let so: SomeObject = SomeObject {
+                    value: t.clone()
+                };
+
+                updated.push(so);
+            }
+
+            // for item in vals {
+                // tmp.push(item.value.clone());
+            // }
+            return updated
         }
         pub fn print_values(&self, vals: &Vec<SomeObject>) {
             for o in vals {
@@ -50,8 +121,13 @@ pub mod parser {
             }
         }
 
-        pub fn save_file(&self, vals: Vec<SomeObject>) {
-            println!("Hi");
+        pub fn save_file(&self, vals: Vec<SomeObject>) -> std::io::Result<()> {
+            let filename: String = String::from("numbers.json");
+
+            let json = serde_json::to_string(&vals).unwrap();
+            let mut file = File::create(filename)?;
+            file.write_all(json.as_bytes())?;
+            Ok(())
         }
 
 
@@ -59,5 +135,53 @@ pub mod parser {
             let file = std::fs::File::open(filename)?;
             Ok(std::io::BufReader::new(file).lines())
         }
+
+        fn remove_some_data(&self, unparsed: &String, remove_chars: &Vec<char>) -> String {
+            println!("Unparsed: {}", unparsed);
+
+            let mut parsed: String = String::new();
+
+            for i in 0..unparsed.len() {
+                let mychar: char = unparsed.chars().nth(i).unwrap();
+
+                if mychar.is_numeric(){
+                    parsed.push(mychar);
+                }
+            }
+
+            println!("Parsed: {}", parsed);
+
+            return parsed;
+        }
+
+        fn add_prefix(&self, raw: String) -> String {
+            let mut mychars = raw.chars().clone();
+            println!("add_prefix");
+            let first_char: char = mychars.nth(0).clone().unwrap();
+            let second_char: char = mychars.nth(1).clone().unwrap();
+            println!("add_prefix");
+
+            let last_char_index = raw.len() - 1;
+            println!("Size {} last index {}", raw.len(), last_char_index);
+
+            // let last_char: char = mychars.nth(last_char_index).clone().unwrap();
+            println!("add_prefix");
+
+            let mut parsed: String = raw.clone();
+
+            if first_char == '1' {
+                parsed.insert(0, '+');
+            } else if first_char != '+' {
+                if second_char != '1' {
+                    parsed.insert(0, '+');
+                    parsed.insert(1, '1');
+                } else {
+                    parsed.insert(0, '+');
+                    parsed.insert(1, '1');
+                } 
+            }
+
+            return parsed
+        }
     }
 }