codeviz_java/
enum_spec.rs

1use super::*;
2
3#[derive(Debug, Clone)]
4pub struct EnumSpec {
5    pub modifiers: Modifiers,
6    pub name: String,
7    pub annotations: Vec<AnnotationSpec>,
8    pub values: Elements,
9    pub fields: Vec<FieldSpec>,
10    pub constructors: Vec<ConstructorSpec>,
11    pub elements: Elements,
12    pub implements: Vec<ClassType>,
13}
14
15impl EnumSpec {
16    pub fn new(modifiers: Modifiers, name: &str) -> EnumSpec {
17        EnumSpec {
18            modifiers: modifiers,
19            name: name.to_owned(),
20            annotations: Vec::new(),
21            values: Elements::new(),
22            fields: Vec::new(),
23            constructors: Vec::new(),
24            elements: Elements::new(),
25            implements: Vec::new(),
26        }
27    }
28
29    pub fn push_value<E>(&mut self, value: E)
30    where
31        E: Into<Element>,
32    {
33        self.values.push(value);
34    }
35}
36
37impl From<EnumSpec> for Element {
38    fn from(value: EnumSpec) -> Element {
39        let mut elements = Elements::new();
40
41        for a in &value.annotations {
42            elements.push(a);
43        }
44
45        // opening statement
46        {
47            let mut open = Statement::new();
48
49            if !value.modifiers.is_empty() {
50                open.push(value.modifiers);
51                open.push(" ");
52            }
53
54            open.push("enum ");
55            open.push(&value.name);
56
57            implements(&value.implements, &mut open);
58
59            open.push(" {");
60
61            elements.push(open);
62        }
63
64        let mut enum_body = Elements::new();
65
66        // enum values
67        {
68            let mut values = Elements::new();
69
70            let mut value_joiner = Elements::new();
71
72            let mut comma = Statement::new();
73            comma.push(",");
74
75            value_joiner.push(Concat(comma));
76
77            values.push(value.values.join(value_joiner));
78
79            let mut endl = Statement::new();
80            endl.push(";");
81
82            values.push(Concat(endl));
83
84            enum_body.push(values);
85        }
86
87        if !value.fields.is_empty() {
88            let mut fields = Elements::new();
89
90            for field in &value.fields {
91                let mut field: Statement = field.clone().into();
92                field.push(";");
93                fields.push(field);
94            }
95
96            enum_body.push(fields);
97        }
98
99        for constructor in value.constructors {
100            enum_body.push(constructor.as_element(&value.name));
101        }
102
103        for element in &value.elements.elements {
104            enum_body.push(element);
105        }
106
107        elements.push_nested(enum_body.join(Spacing));
108        elements.push("}");
109
110        elements.into()
111    }
112}