v0.2.3 linted, public API changed.

Author: LEXUGE

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lib_xch"
-version = "0.2.1"
+version = "0.2.3"
 authors = ["LEXUGE <LEXUGEyky@outlook.com>"]
 description = "Crate xch-ceb's official lib"
 license = "GPL-3.0"

Cargo.toml

@@ -24,7 +24,7 @@ pub fn xch_try(
     f: i32,
     searching_range: i32,
     traversal: &mut Vec<i32>,
-    list: &Vec<Vec<i32>>,
+    list: &[Vec<i32>],
     chmcl_f_sut: &ChemicalEquation,
     len: usize,
 ) -> Result<bool, String> {
@@ -50,18 +50,18 @@ pub fn xch_try(
 
 fn check(
     traversal: &mut Vec<i32>,
-    list: &Vec<Vec<i32>>,
+    list: &[Vec<i32>],
     chmcl_f_sut: &ChemicalEquation,
     len: usize,
 ) -> Result<bool, String> {
     let mut tmp1: i32;
     let mut tmp2: i32;
-    for i in 1..len + 1 {
+    for item in list.iter().take(len + 1).skip(1) {
         tmp1 = 0;
         tmp2 = 0;
         for j in 1..chmcl_f_sut.left_num as usize + 1 {
             let tmp: i32;
-            tmp = match list[i][j].checked_mul(traversal[j - 1]) {
+            tmp = match item[j].checked_mul(traversal[j - 1]) {
                 Some(s) => s,
                 None => return Err("[ERROR] i32 overflow".to_string()),
             };
@@ -72,7 +72,7 @@ fn check(
         }
         for j in chmcl_f_sut.left_num as usize + 1..chmcl_f_sut.sum as usize + 1 {
             let tmp: i32;
-            tmp = match list[i][j].checked_mul(traversal[j - 1]) {
+            tmp = match item[j].checked_mul(traversal[j - 1]) {
                 Some(s) => s,
                 None => return Err("[ERROR] i32 overflow".to_string()),
             };

src/balancer_mod.rs

@@ -27,7 +27,7 @@ use balancer_mod::xch_try;
 /// In following cases, API will **panic**:
 /// 1.Stack Overflow may cause panic too. Because it is using recusive balancer and regex-based parser.
 /// And in the other failed situation, it'll return a `error_message` and contain `parser_result`(maybe it is empty).
-pub fn handler_api(equation: String, searching_range: i32) -> Result<Vec<i32>, ErrorHandler> {
+pub fn handler_api(equation: &str, 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_len, list) = match xch_parser(equation) {
@@ -62,8 +62,8 @@ pub fn handler_api(equation: String, searching_range: i32) -> Result<Vec<i32>, E
     }
 }
 
-/// ErrorHandler returns when `handler::handler_api` failed somehow.
-/// **CAUTION: parser_result might empty if parser is failed.**
+/// `ErrorHandler` returns when `handler::handler_api` failed somehow.
+/// **CAUTION: `parser_result` might empty if parser is failed.**
 pub struct ErrorHandler {
     pub error_message: String,
     pub parser_result: Vec<Vec<i32>>,

src/handler.rs

@@ -14,7 +14,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // extern crate(s)
-#[macro_use] extern crate lazy_static;
+#[macro_use]
+extern crate lazy_static;
 extern crate regex;
 
 // mods

src/lib.rs

@@ -15,15 +15,15 @@
 
 // Overall: This is the source code of the Delta-3 Parser.
 
-pub fn legal_check(equation: &String) -> Result<bool, String> {
+pub fn legal_check(equation: &str) -> Result<bool, String> {
     let equation = equation.chars().into_iter().collect::<Vec<_>>();
     let mut tmp = 0;
     for i in equation {
         if check_char(i) == 0 {
             return Err("[ERROR] Illegal Equation!".to_string());
         }
         if i == '=' {
-            tmp = tmp + 1;
+            tmp += 1;
         }
     }
     if tmp != 1 {
@@ -32,7 +32,7 @@ pub fn legal_check(equation: &String) -> Result<bool, String> {
     Ok(true)
 }
 
-pub fn legal_check_brackets(formula: &String) -> Result<bool, String> {
+pub fn legal_check_brackets(formula: &str) -> Result<bool, String> {
     let formula = formula.chars().into_iter().collect::<Vec<_>>();
     for i in 0..formula.len() {
         if formula[i] == '(' {
@@ -45,32 +45,32 @@ pub fn legal_check_brackets(formula: &String) -> Result<bool, String> {
     Ok(true)
 }
 
-fn brackets_matcher(formula: &Vec<char>, pos: usize, mode: bool) -> Result<usize, String> {
+fn brackets_matcher(formula: &[char], pos: usize, mode: bool) -> Result<usize, String> {
     let mut fake_stack = 0;
 
-    if mode == true {
-        for i in pos + 1..formula.len() {
-            if formula[i] == '(' {
-                fake_stack = fake_stack + 1;
+    if mode {
+        for (i, item) in formula.iter().enumerate().skip(pos + 1) {
+            if *item == '(' {
+                fake_stack += 1;
             }
-            if formula[i] == ')' {
+            if *item == ')' {
                 if fake_stack == 0 {
                     return Ok(i);
                 } else {
-                    fake_stack = fake_stack - 1;
+                    fake_stack -= 1;
                 }
             }
         }
     } else {
         for i in (0..pos).rev() {
             if formula[i] == ')' {
-                fake_stack = fake_stack + 1;
+                fake_stack += 1;
             }
             if formula[i] == '(' {
                 if fake_stack == 0 {
                     return Ok(i);
                 } else {
-                    fake_stack = fake_stack - 1;
+                    fake_stack -= 1;
                 }
             }
         }
@@ -80,16 +80,16 @@ fn brackets_matcher(formula: &Vec<char>, pos: usize, mode: bool) -> Result<usize
 
 fn check_char(test: char) -> i32 {
     if (test >= 'a') && (test <= 'z') {
-        return 1; // 'a'~'z'
+        1 // 'a'~'z'
     } else if (test >= 'A') && (test <= 'Z') {
-        return 2; // 'A'~'Z'
+        2 // 'A'~'Z'
     } else if (test >= '0') && (test <= '9') {
-        return 3; // '0'~'9'
+        3 // '0'~'9'
     } else if (test == '(') || (test <= ')') {
-        return 4; // ( or )
+        4 // ( or )
     } else if (test == '+') || (test == '=') {
-        return 5; // + or =
+        5 // + or =
     } else {
-        return 0; // nothing!
+        0 // nothing!
     }
 }

src/parser_mod/legal_check_util.rs

@@ -25,17 +25,18 @@ use std::vec::Vec;
 use std::i32;
 // inside uses
 use structs::ChemicalEquation;
-use self::parser_struct::{TableDesc,FormulaDesc,TokenDesc};
+use self::parser_struct::{FormulaDesc, TableDesc, TokenDesc};
 use self::legal_check_util::{legal_check, legal_check_brackets};
 
-pub fn xch_parser(equation: String) -> Result<(ChemicalEquation, usize, Vec<Vec<i32>>),String> {
-    legal_check(&equation)?;
+pub fn xch_parser(equation: &str) -> Result<(ChemicalEquation, usize, Vec<Vec<i32>>), String> {
+    legal_check(equation)?;
     let mut chemical_equation_struct = ChemicalEquation {
         left_num: 0,
         right_num: 0,
         sum: 0,
     };
-    { // block to get chemical_equation_struct.sum
+    {
+        // 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]);
@@ -45,16 +46,13 @@ pub fn xch_parser(equation: String) -> Result<(ChemicalEquation, usize, Vec<Vec<
     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
+    {
+        // 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 table,
-            0,
-        )?;
+        chemical_equation_struct.left_num = part_parser(&equation_left, &mut table, 0)?;
         chemical_equation_struct.right_num = part_parser(
             &equation_right,
             &mut table,
@@ -63,10 +61,14 @@ pub fn xch_parser(equation: String) -> Result<(ChemicalEquation, usize, Vec<Vec<
     }
 
     // return
-    Ok((chemical_equation_struct, table.get_elements_table_len(), table.get_list()))
+    Ok((
+        chemical_equation_struct,
+        table.get_elements_table_len(),
+        table.get_list(),
+    ))
 }
 
-fn parser_get_sum(equation: &String) -> Result<i32,String> {
+fn parser_get_sum(equation: &str) -> Result<i32, String> {
     let mut sum: i32 = 0;
     for _ in equation.split('+') {
         sum = match sum.checked_add(1) {
@@ -77,20 +79,12 @@ fn parser_get_sum(equation: &String) -> Result<i32,String> {
     Ok(sum)
 }
 
-fn part_parser(
-    equation: &String,
-    table: &mut TableDesc,
-    begin: i32,
-) -> Result<i32,String> {
+fn part_parser(equation: &str, table: &mut TableDesc, begin: i32) -> Result<i32, String> {
     let mut sum = begin;
     for formula in equation.split('+') {
-        sum = sum + 1;
+        sum += 1;
         legal_check_brackets(&formula.to_string())?;
-        parser_formula(
-            &formula.to_string(),
-            table,
-            sum as usize,
-        )?;
+        parser_formula(&formula.to_string(), table, sum as usize)?;
     }
     Ok(sum - begin)
 }
@@ -101,7 +95,7 @@ fn formula_spliter(target: &str) -> Result<Vec<FormulaDesc>, String> {
         static ref RE: Regex = Regex::new(r"\((([A-Z][a-z]*(\d+)*)+)\)(\d+)*").unwrap();
     }
 
-    if RE.is_match(target) == false {
+    if !RE.is_match(target) {
         return Err("[ERROR] No more to split!".to_string());
     }
     for cap in RE.captures_iter(target) {
@@ -124,12 +118,12 @@ fn formula_spliter(target: &str) -> Result<Vec<FormulaDesc>, String> {
     Ok(v)
 }
 
-fn get_token(target: &str) -> Result<Vec<TokenDesc>,String> {
+fn get_token(target: &str) -> Result<Vec<TokenDesc>, String> {
     let mut v: Vec<TokenDesc> = Vec::new();
     lazy_static! {
         static ref RE: Regex = Regex::new(r"([A-Z][a-z]*)(\d+)*").unwrap();
     }
-    if RE.is_match(target) == false {
+    if !RE.is_match(target) {
         return Err("[ERROR] No tokens!".to_string());
     }
     for cap in RE.captures_iter(target) {
@@ -151,7 +145,7 @@ fn get_token(target: &str) -> Result<Vec<TokenDesc>,String> {
     Ok(v)
 }
 
-fn mul_phrase(phrase: &FormulaDesc) -> Result<String,String> {
+fn mul_phrase(phrase: &FormulaDesc) -> Result<String, String> {
     let mut v = get_token(&phrase.formula_self)?;
     for token in &mut v {
         token.times = match token.times.checked_mul(phrase.times) {
@@ -173,18 +167,18 @@ fn replace_phrase(target: &str, src: &str, des: &str) -> String {
 
 fn parser_formula(
     // parse the chemical formula
-    formula: &String,
+    formula: &str,
     table: &mut TableDesc,
     location: usize,
-) -> Result<bool, String>{
+) -> Result<bool, String> {
     let formula_backup = formula;
     let mut formula = format!("({})", formula_backup);
 
-    while formula_spliter(&formula).is_ok() == true {
+    while formula_spliter(&formula).is_ok() {
         for p in formula_spliter(&formula)? {
             formula = replace_phrase(&formula, &p.all, &(mul_phrase(&p)?));
         }
     }
-    table.store_in_table(&formula,location)?;
+    table.store_in_table(&formula, location)?;
     Ok(true)
 }

src/parser_mod/mod.rs

@@ -38,9 +38,9 @@ pub struct TableDesc {
 }
 
 impl TableDesc {
-    pub fn store_in_table(&mut self, formula: &String, location: usize) -> Result<bool, String> {
+    pub fn store_in_table(&mut self, formula: &str, location: usize) -> Result<bool, String> {
         for t in get_token(formula)? {
-            if self.find_element_in_table(&t.token_name).is_ok() == false {
+            if !self.find_element_in_table(&t.token_name).is_ok() {
                 let len = self.elements_table.len();
                 self.elements_table.push(ElementStruct {
                     name: t.token_name.clone(),
@@ -69,7 +69,8 @@ impl TableDesc {
         (self.list).to_vec()
     }
 
-    pub fn new(sum: i32) -> Self { // PLEASE call update_list_vec after new!
+    pub fn new(sum: i32) -> Self {
+        // PLEASE call update_list_vec after new!
         Self {
             elements_table: Vec::new(),
             list: Vec::new(),
@@ -90,7 +91,7 @@ impl TableDesc {
         v
     }
 
-    fn find_element_in_table(&self, target: &String) -> Result<usize, String> {
+    fn find_element_in_table(&self, target: &str) -> Result<usize, String> {
         for i in &(self.elements_table) {
             if i.name == *target {
                 return Ok(i.num);

src/parser_mod/parser_struct.rs

@@ -17,21 +17,21 @@ extern crate lib_xch;
 
 mod testers;
 
-use testers::{tester,tester_error};
+use testers::{tester, tester_error};
 
 #[test]
 fn simples() {
-    tester("H2O=H2+O2", 10, vec![2, 2, 1]);
+    tester("H2O=H2+O2", 10, &[2, 2, 1]);
 }
 
 #[test]
 fn high_performance() {
-    tester("As2O3+Zn+HCl=AsH3+ZnCl2+H2O", 50, vec![1, 6, 12, 2, 6, 3]);
+    tester("As2O3+Zn+HCl=AsH3+ZnCl2+H2O", 50, &[1, 6, 12, 2, 6, 3]);
 }
 
 #[test]
 fn brackets() {
-    tester("O2(O3(O)4O5(O))=O", 50, vec![1, 15]);
+    tester("O2(O3(O)4O5(O))=O", 50, &[1, 15]);
 }
 
 #[test]