codeviz 0.0.15

Flexible code generator for Rust
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

use common::ElementFormat;
use errors::*;
use super::elements::Elements;
use super::statement::Statement;
use super::variable_format::VariableFormat;

#[derive(Debug, Clone)]
pub enum Element<Var>
    where Var: VariableFormat
{
    Push(Statement<Var>),
    Concat(Statement<Var>),
    Literal(String),
    Inner(Vec<Element<Var>>),
    Nested(Box<Element<Var>>),
    Spacing,
}

impl<Var> Element<Var>
    where Var: VariableFormat
{
    pub fn format<E>(&self, out: &mut E) -> Result<()>
        where E: ElementFormat
    {
        match *self {
            Element::Push(ref statement) => {
                out.new_line_unless_empty()?;
                statement.format(out, 0usize)?;
            }
            Element::Concat(ref statement) => {
                statement.format(out, 0usize)?;
            }
            Element::Literal(ref line) => {
                out.new_line_unless_empty()?;
                out.write_str(line)?;
            }
            Element::Inner(ref elements) => {
                for element in elements {
                    element.format(out)?;
                }
            }
            Element::Nested(ref element) => {
                out.new_line_unless_empty()?;

                out.indent();
                element.format(out)?;
                out.unindent();
            }
            Element::Spacing => {
                out.new_line_unless_empty()?;
                out.new_line()?;
            }
        }

        Ok(())
    }
}

impl<'a, T, Var> From<&'a T> for Element<Var>
    where T: Into<Element<Var>> + Clone,
          Var: VariableFormat
{
    fn from(value: &'a T) -> Element<Var> {
        value.clone().into()
    }
}

impl<'a, Var> From<&'a str> for Element<Var>
    where Var: VariableFormat
{
    fn from(value: &'a str) -> Element<Var> {
        Element::Literal(value.to_owned())
    }
}

impl<Var> From<Elements<Var>> for Element<Var>
    where Var: VariableFormat
{
    fn from(value: Elements<Var>) -> Element<Var> {
        Element::Inner(value.elements)
    }
}

impl<Var> From<Vec<String>> for Element<Var>
    where Var: VariableFormat
{
    fn from(value: Vec<String>) -> Element<Var> {
        Element::Inner(value.into_iter().map(Element::Literal).collect())
    }
}

impl<Var> ToString for Element<Var>
    where Var: VariableFormat
{
    fn to_string(&self) -> String {
        let mut s = String::new();
        self.format(&mut ::common::ElementFormatter::new(&mut s)).unwrap();
        s
    }
}