tref 0.4.0

Tree in Rows Elemental Format (TREF). Crate to parse, store and serialize trees.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::error::Error;
use std::fmt;

#[derive(Debug)]
/// Parse TREF document error.
pub struct ParseTreeError {
    message: String,
    line: usize
}

impl ParseTreeError {
    /// Create new parse tree error.
    /// 
    /// # Arguments
    /// 
    /// * `msg` - Error message.
    /// * `line` - Document line where the error hapened.
    /// 
    /// # Return
    /// 
    /// * An error model.
    ///
    pub fn new(msg: &str, line: usize) -> Self {
        ParseTreeError {
            message: String::from(msg),
            line
        }
    }

    /// Get error line.
    /// 
    /// # Return
    /// 
    /// * Line.
    ///
    pub fn line(&self) -> usize {
        self.line
    }
}

impl fmt::Display for ParseTreeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "`{}` at line {}", self.message, self.line + 1)
    }
}

impl Error for ParseTreeError {
    fn description(&self) -> &str {
        &self.message
    }
}

#[derive(Debug)]
/// Serializer error.
pub struct SerializeTreeError {
    message: String,
    line: usize,
    statement: Option<String>
}

impl SerializeTreeError {
    /// Create new serializer error.
    /// 
    /// # Arguments
    /// 
    /// * `msg` - Error message.
    /// * `line` - File line.
    /// * `statement` - Statement that caused the problem.
    /// 
    /// # Return
    /// 
    /// * An error model.
    ///
    pub fn new(message: &str, line: usize, statement: Option<String>) -> Self {
        SerializeTreeError {
            message: String::from(message),
            line,
            statement
        }
    }

    /// Get error line.
    /// 
    /// # Return
    /// 
    /// * Line.
    ///
    pub fn line(&self) -> usize {
        self.line
    }

    /// Get statement that caused the error.
    /// 
    /// # Return
    /// 
    /// * Statement.
    ///
    pub fn statement(&self) -> &Option<String> {
        &self.statement
    }
}

impl fmt::Display for SerializeTreeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if let Some(statement) = &self.statement {
            write!(f, "`{}` at line {} with statement {}", self.message, self.line, statement)
        }
        else {
            write!(f, "`{}` at line {}", self.message, self.line)
        }
    }
}

impl Error for SerializeTreeError {
    fn description(&self) -> &str {
        &self.message
    }
}