xenon_codegen/
trait.rs

1use core::fmt;
2use std::vec;
3
4use crate::{
5    Visibility, attribute::Attribute, function::Function, r#type::Type,
6    variable_definition::VariableDefinition,
7};
8
9#[derive(Debug, Clone, Default)]
10pub struct Trait {
11    pub attrs: Vec<Attribute>,
12    pub visibility: Visibility,
13    pub name: Type,
14    pub fields: Vec<VariableDefinition>,
15    pub methods: Vec<Function>,
16}
17impl Trait {
18    pub fn new(name: Type) -> Trait {
19        Trait {
20            attrs: vec![],
21            visibility: Visibility::Private,
22            name,
23            fields: vec![],
24            methods: vec![],
25        }
26    }
27
28    pub fn is_valid(&self) -> bool {
29        for i in 0..self.attrs.len() {
30            if !self.attrs[i].is_valid() {
31                return false;
32            }
33        }
34        if !self.name.is_valid() {
35            return false;
36        }
37        for i in 0..self.fields.len() {
38            if !self.fields[i].is_valid() {
39                return false;
40            }
41        }
42        for i in 0..self.methods.len() {
43            if !self.methods[i].is_valid() {
44                return false;
45            }
46        }
47        true
48    }
49}
50impl fmt::Display for Trait {
51    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
52        for i in 0..self.attrs.len() {
53            match write!(fmt, "{}", self.attrs[i]) {
54                Ok(_) => (),
55                Err(e) => return Err(e),
56            }
57        }
58        match writeln!(fmt, "{} trait {} {{", self.visibility, self.name) {
59            Ok(_) => (),
60            Err(e) => return Err(e),
61        }
62        for i in 0..self.fields.len() {
63            match write!(fmt, "{}", self.fields[i]) {
64                Ok(_) => (),
65                Err(e) => return Err(e),
66            }
67        }
68        for i in 0..self.methods.len() {
69            match write!(fmt, "{}", self.methods[i]) {
70                Ok(_) => (),
71                Err(e) => return Err(e),
72            }
73        }
74        match write!(fmt, "}}") {
75            Ok(_) => (),
76            Err(e) => return Err(e),
77        }
78        Ok(())
79    }
80}