atomio 0.1.0

Crate to parse chemical formula
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use pest::{Parser, iterators::Pair};
use pest_derive::Parser;

use crate::unit::Unit;

///! Struct to parse molecular formula using pest.rs
#[derive(Parser)]
#[grammar = "grammar.pest"]
pub struct MoleculeParser {}

///! Tree data structure to hold the tree of elements and thier count
#[derive(Clone,Debug,PartialEq,Eq, PartialOrd, Ord)]
pub struct Parsed {
    /// Root unit of the tree.
    pub root_unit: Unit,
}

impl TryFrom<String> for Parsed {
    type Error = String;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        value.as_str().try_into()
    }
}

impl TryFrom<&str> for Parsed {
    type Error = String;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        let main = match MoleculeParser::parse(Rule::main, value) {
            Err(_) => return Err("Unable to parse chemical formula.".to_string()),
            Ok(e) => e
        };

        let count = 1;
        let mut units = vec![];

        for p in main {
            match p.as_rule() {
                Rule::EOI => {}
                _ => units.push(Parsed::get_unit_tree(p)),
            }
        }

        Ok(Parsed {root_unit: Unit::ElementGroup {
            count,
            units
        }})
    }
}


impl Parsed {
    fn get_unit_tree(p: Pair<Rule>) -> Unit {
        match p.as_rule() {
            Rule::element => {
                let mut symbol = String::new();
                let mut count = 0;

                for i in p.into_inner() {
                    match i.as_rule() {
                        Rule::count => {
                            count = i.as_span().as_str().parse::<u32>().unwrap();
                        }
                        Rule::element_name => {
                            symbol = i.as_span().as_str().to_string()
                        }
                        _ => unreachable!(),
                    }
                }

                Unit::Element{
                    symbol,
                    count
                }
            }
            Rule::group | Rule::root_group => {
                let mut count = 0;
                let mut units = vec![];

                for i in p.into_inner() {
                    match i.as_rule() {
                        Rule::count | Rule::root_count => {
                            count =  i.as_span().as_str().parse::<u32>().unwrap();
                        }
                        Rule::element | Rule::root_group | Rule::group => {
                            units.push(Parsed::get_unit_tree(i))
                        }
                        _ => unreachable!("{:?}", i),
                    }
                }

                Unit::ElementGroup {
                    count,
                    units
                }
            }
            _ => unreachable!("{:?}", p),
        }
    }
}