v0.2.1 OOP restructured, added integration-tests and fixed bugs

Author: LEXUGE

Cargo.lock

@@ -1,11 +1,11 @@
 [package]
 name = "lib_xch"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["LEXUGE <LEXUGEyky@outlook.com>"]
 description = "Crate xch-ceb's official lib"
 license = "GPL-3.0"
 repository = "https://github.com/LEXUGE/lib-xch-ceb"
 
 [dependencies]
-lazy_static = "1.0.0"
-regex = "0.2.5"
+lazy_static = "^1.x"
+regex = "^0.2"

Cargo.toml

@@ -1,2 +1,7 @@
 # lib-xch-ceb
-Crate xch-ceb's library
+This is crate [xch-ceb](https://crates.io/crates/xch-ceb)'s official lib.  
+[lib_xch on crates.io](https://crates.io/crates/lib_xch)  
+[lib_xch's documentation](https://docs.rs/lib_xch)  
+
+# Goal
+Fast, Small, Safe.  

README.md

@@ -30,7 +30,7 @@ use balancer_mod::xch_try;
 pub fn handler_api(equation: String, searching_range: i32) -> Result<Vec<i32>, ErrorHandler> {
     // T is successful traversal vector, E is list vector which parser returned.
     let mut traversal: Vec<i32> = Vec::new();
-    let (chemical_equation_struct, elements_table, list) = match xch_parser(equation) {
+    let (chemical_equation_struct, elements_table_len, list) = match xch_parser(equation) {
         Ok(some) => some,
         Err(e) => {
             return Err(ErrorHandler {
@@ -48,7 +48,7 @@ pub fn handler_api(equation: String, searching_range: i32) -> Result<Vec<i32>, E
         &mut traversal,
         &list,
         &chemical_equation_struct,
-        elements_table.len(),
+        elements_table_len,
     ) {
         Ok(true) => Ok(traversal),
         Ok(false) => Err(ErrorHandler {

src/handler.rs

@@ -22,6 +22,3 @@ pub mod handler;
 mod parser_mod;
 mod balancer_mod;
 mod structs;
-
-#[cfg(test)]
-mod tests;

src/lib.rs

@@ -13,6 +13,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+// Overall: This is the source code of the Delta-3 Parser.
+
 pub fn legal_check(equation: &String) -> Result<bool, String> {
     let equation = equation.chars().into_iter().collect::<Vec<_>>();
     let mut tmp = 0;
@@ -53,8 +55,7 @@ fn brackets_matcher(formula: &Vec<char>, pos: usize, mode: bool) -> Result<usize
             }
             if formula[i] == ')' {
                 if fake_stack == 0 {
-                    let x: Result<usize, String> = Ok(i);
-                    return x;
+                    return Ok(i);
                 } else {
                     fake_stack = fake_stack - 1;
                 }

src/parser_mod/legal_check_util.rs

@@ -17,64 +17,53 @@
 
 // mods
 mod legal_check_util;
+mod parser_struct;
 
 use regex::Regex;
 use std::string::String;
 use std::vec::Vec;
 use std::i32;
 // inside uses
-use structs::{ChemicalEquation, ElementStruct};
+use structs::ChemicalEquation;
+use self::parser_struct::{TableDesc,FormulaDesc,TokenDesc};
 use self::legal_check_util::{legal_check, legal_check_brackets};
 
-struct FormulaDesc {
-    formula_self: String,
-    times: i32,
-    all: String,
-}
-
-struct TokenDesc {
-    token_name: String,
-    times: i32,
-}
-
-pub fn xch_parser(equation: String) -> Result<(ChemicalEquation, Vec<ElementStruct>, Vec<Vec<i32>>),String> {
+pub fn xch_parser(equation: String) -> Result<(ChemicalEquation, usize, Vec<Vec<i32>>),String> {
     legal_check(&equation)?;
     let mut chemical_equation_struct = ChemicalEquation {
         left_num: 0,
         right_num: 0,
         sum: 0,
     };
-    let mut elements_table: Vec<ElementStruct> = Vec::new(); // store the index of elements
-    let mut list: Vec<Vec<i32>> = Vec::new();
-    // Unicode slice safe
-
-    // block to call parsers
-    {
+    { // block to get chemical_equation_struct.sum
         let v: Vec<&str> = equation.split('=').collect();
         let equation_left: String = String::from(v[0]);
         let equation_right: String = String::from(v[1]);
-
         chemical_equation_struct.sum =
             parser_get_sum(&equation_left)? + parser_get_sum(&equation_right)?;
-        list.push(generate_n_vec(chemical_equation_struct.sum + 1)); // first access will be like list[1][1]
+    }
+    let mut table = TableDesc::new(chemical_equation_struct.sum);
+    table.update_list_vec(); // first access will be like list[1][1]
+
+    { // block to call parsers
+        let v: Vec<&str> = equation.split('=').collect();
+        let equation_left: String = String::from(v[0]);
+        let equation_right: String = String::from(v[1]);
+
         chemical_equation_struct.left_num = part_parser(
             &equation_left,
-            &mut elements_table,
-            &mut list,
+            &mut table,
             0,
-            chemical_equation_struct.sum,
         )?;
         chemical_equation_struct.right_num = part_parser(
             &equation_right,
-            &mut elements_table,
-            &mut list,
+            &mut table,
             chemical_equation_struct.left_num,
-            chemical_equation_struct.sum,
         )?;
     }
 
     // return
-    Ok((chemical_equation_struct, elements_table, list))
+    Ok((chemical_equation_struct, table.get_elements_table_len(), table.get_list()))
 }
 
 fn parser_get_sum(equation: &String) -> Result<i32,String> {
@@ -90,34 +79,22 @@ fn parser_get_sum(equation: &String) -> Result<i32,String> {
 
 fn part_parser(
     equation: &String,
-    elements_table: &mut Vec<ElementStruct>,
-    list: &mut Vec<Vec<i32>>,
+    table: &mut TableDesc,
     begin: i32,
-    equation_sum: i32,
 ) -> Result<i32,String> {
     let mut sum = begin;
     for formula in equation.split('+') {
         sum = sum + 1;
         legal_check_brackets(&formula.to_string())?;
         parser_formula(
             &formula.to_string(),
-            elements_table,
+            table,
             sum as usize,
-            list,
-            equation_sum,
         )?;
     }
     Ok(sum - begin)
 }
 
-fn generate_n_vec(n: i32) -> Vec<i32> {
-    let mut v: Vec<i32> = Vec::new();
-    for _ in 0..n {
-        v.push(0);
-    }
-    v
-}
-
 fn formula_spliter(target: &str) -> Result<Vec<FormulaDesc>, String> {
     let mut v: Vec<FormulaDesc> = Vec::new();
     lazy_static! {
@@ -194,60 +171,20 @@ fn replace_phrase(target: &str, src: &str, des: &str) -> String {
     str::replace(target, src, des)
 }
 
-fn store_in_table(
-    formula: &String,
-    elements_table: &mut Vec<ElementStruct>,
-    location: usize,
-    list: &mut Vec<Vec<i32>>,
-    formula_sum: i32,
-) -> Result<bool, String> {
-    for t in get_token(formula)? {
-        if find_element_in_table(&t.token_name, elements_table).is_ok() == false {
-            let len = elements_table.len();
-            elements_table.push(ElementStruct {
-                name: t.token_name.clone(),
-                num: len + 1, // WARN: the elements_table[0].num will be 1
-            });
-            list.push(generate_n_vec(formula_sum + 1));
-        }
-
-        {
-            // store data in table
-            let tmp = find_element_in_table(&t.token_name, elements_table).unwrap();
-            list[tmp][location] = match list[tmp][location].checked_add(t.times) {
-                Some(s) => s,
-                None => return Err("[ERROR] i32 overflow".to_string()),
-            }
-        }
-    }
-    Ok(true)
-}
-
 fn parser_formula(
     // parse the chemical formula
     formula: &String,
-    elements_table: &mut Vec<ElementStruct>,
+    table: &mut TableDesc,
     location: usize,
-    list: &mut Vec<Vec<i32>>,
-    formula_sum: i32,
 ) -> Result<bool, String>{
     let formula_backup = formula;
     let mut formula = format!("({})", formula_backup);
 
     while formula_spliter(&formula).is_ok() == true {
-        for p in formula_spliter(&formula).unwrap() {
+        for p in formula_spliter(&formula)? {
             formula = replace_phrase(&formula, &p.all, &(mul_phrase(&p)?));
         }
     }
-    store_in_table(&formula, elements_table, location, list, formula_sum)?;
+    table.store_in_table(&formula,location)?;
     Ok(true)
 }
-
-fn find_element_in_table(target: &String, e_t: &mut Vec<ElementStruct>) -> Result<usize, String> {
-    for i in e_t {
-        if i.name == *target {
-            return Ok(i.num);
-        }
-    }
-    Err("[ERROR] Not found!".to_string())
-}

src/parser_mod/mod.rs

@@ -0,0 +1,101 @@
+// Copyright 2017-2018 LEXUGE
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Overall: This is the source code of the Delta-3 Parser.
+
+// inside uses
+use structs::ElementStruct;
+use parser_mod::get_token;
+
+pub struct FormulaDesc {
+    pub formula_self: String,
+    pub times: i32,
+    pub all: String,
+}
+
+pub struct TokenDesc {
+    pub token_name: String,
+    pub times: i32,
+}
+
+// Object-Oriented
+pub struct TableDesc {
+    elements_table: Vec<ElementStruct>, // store the index of elements
+    list: Vec<Vec<i32>>,
+    formula_sum: i32,
+}
+
+impl TableDesc {
+    pub fn store_in_table(&mut self, formula: &String, location: usize) -> Result<bool, String> {
+        for t in get_token(formula)? {
+            if self.find_element_in_table(&t.token_name).is_ok() == false {
+                let len = self.elements_table.len();
+                self.elements_table.push(ElementStruct {
+                    name: t.token_name.clone(),
+                    num: len + 1, // WARN: the elements_table[0].num will be 1
+                });
+                self.update_list_vec();
+            }
+
+            {
+                // store data in table
+                let tmp = self.find_element_in_table(&t.token_name)?; // It have been checked.
+                self.list[tmp][location] = match self.list[tmp][location].checked_add(t.times) {
+                    Some(s) => s,
+                    None => return Err("[ERROR] i32 overflow".to_string()),
+                }
+            }
+        }
+        Ok(true)
+    }
+
+    pub fn get_elements_table_len(&self) -> usize {
+        self.elements_table.len()
+    }
+
+    pub fn get_list(&self) -> Vec<Vec<i32>> {
+        (self.list).to_vec()
+    }
+
+    pub fn new(sum: i32) -> Self { // PLEASE call update_list_vec after new!
+        Self {
+            elements_table: Vec::new(),
+            list: Vec::new(),
+            formula_sum: sum,
+        }
+    }
+
+    pub fn update_list_vec(&mut self) {
+        let v = self.generate_vec();
+        self.list.push(v);
+    }
+
+    fn generate_vec(&self) -> Vec<i32> {
+        let mut v: Vec<i32> = Vec::new();
+        for _ in 0..self.formula_sum + 1 {
+            v.push(0);
+        }
+        v
+    }
+
+    fn find_element_in_table(&self, target: &String) -> Result<usize, String> {
+        for i in &(self.elements_table) {
+            if i.name == *target {
+                return Ok(i.num);
+            }
+        }
+        Err("[ERROR] Not found!".to_string())
+    }
+}