159 lines
4.4 KiB
Rust
159 lines
4.4 KiB
Rust
|
|
pub mod parser {
|
|
use std::collections::HashSet;
|
|
use std::fs::File;
|
|
use std::io::{BufRead, BufReader};
|
|
use std::io::prelude::*;
|
|
|
|
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
|
|
#[derive(Clone, Deserialize, Serialize)]
|
|
pub struct SomeObject {
|
|
pub value: String
|
|
}
|
|
|
|
|
|
pub struct NumberParser {
|
|
pub filepath: String
|
|
}
|
|
|
|
impl NumberParser {
|
|
pub fn filedump(&self) -> Vec<SomeObject> {
|
|
let mut objs: Vec<SomeObject> = Vec::new();
|
|
|
|
if let Ok(lines) = self.read_lines(&self.filepath) {
|
|
for line in lines {
|
|
if let Ok(phonenumber) = line {
|
|
let myobj: SomeObject = SomeObject {
|
|
value: phonenumber
|
|
};
|
|
|
|
if !myobj.value.is_empty() {
|
|
objs.push(myobj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return objs;
|
|
}
|
|
|
|
pub fn updatevalues(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
|
|
let mut updated: Vec<SomeObject> = Vec::new();
|
|
|
|
let mut i: i32 = 0;
|
|
|
|
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 pars = self.remove_some_data(&parsed);
|
|
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>) -> Vec<SomeObject> {
|
|
let mut tmp: HashSet<String> = HashSet::new();
|
|
let mut mm: Vec<SomeObject> = Vec::new();
|
|
mm.clone_from(vals);
|
|
mm.retain(|e| tmp.insert(e.value.clone()));
|
|
|
|
let mut updated: Vec<SomeObject> = Vec::new();
|
|
|
|
for t in tmp {
|
|
let so: SomeObject = SomeObject {
|
|
value: t.clone()
|
|
};
|
|
|
|
updated.push(so);
|
|
}
|
|
|
|
return updated
|
|
}
|
|
pub fn print_values(&self, vals: &Vec<SomeObject>) {
|
|
for o in vals {
|
|
println!("Value: {}", o.value);
|
|
}
|
|
}
|
|
|
|
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(())
|
|
}
|
|
|
|
|
|
fn read_lines(&self, filename: &str) -> std::io::Result<std::io::Lines<BufReader<File>>> {
|
|
let file = File::open(filename)?;
|
|
Ok(BufReader::new(file).lines())
|
|
}
|
|
|
|
fn remove_some_data(&self, unparsed: &String) -> 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();
|
|
let first_char: char = mychars.nth(0).clone().unwrap();
|
|
let second_char: char = mychars.nth(1).clone().unwrap();
|
|
|
|
let last_char_index = raw.len() - 1;
|
|
println!("Size {} last index {}", raw.len(), last_char_index);
|
|
|
|
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
|
|
}
|
|
}
|
|
}
|