tin 0.3.0

tin: a statically structurally typed embeddable programming language
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::fmt;

use specs::Component;
use specs::VecStorage;

#[derive(Clone, Component, Debug, VisitEntities, VisitEntitiesMut)]
#[storage(VecStorage)]
pub struct Layout {
    pub size: usize,
    pub alignment: usize,
    pub named_fields: Option<Vec<NamedField>>,
    pub unnamed_fields: Option<Vec<OffsetLayout>>,
}

#[derive(Clone, Debug, VisitEntities, VisitEntitiesMut)]
pub struct NamedField {
    pub field: String,
    pub offset_layout: OffsetLayout,
}

#[derive(Clone, Debug, VisitEntities, VisitEntitiesMut)]
pub struct OffsetLayout {
    pub offset: usize,
    pub layout: Layout,
}

impl Layout {
    pub const fn zero() -> Layout {
        Layout {
            size: 0,
            alignment: 1,
            named_fields: None,
            unnamed_fields: None,
        }
    }

    pub const fn scalar(size: usize) -> Layout {
        Layout {
            size,
            alignment: size,
            named_fields: None,
            unnamed_fields: None,
        }
    }

    pub fn named_fields(size: usize, alignment: usize, named_fields: Vec<NamedField>) -> Layout {
        let named_fields = Some(named_fields);
        let unnamed_fields = None;

        Layout {
            size,
            alignment,
            named_fields,
            unnamed_fields,
        }
    }

    pub fn unnamed_fields(
        size: usize,
        alignment: usize,
        unnamed_fields: Vec<OffsetLayout>,
    ) -> Layout {
        let named_fields = None;
        let unnamed_fields = Some(unnamed_fields);

        Layout {
            size,
            alignment,
            named_fields,
            unnamed_fields,
        }
    }
}

impl OffsetLayout {
    pub const fn zero() -> OffsetLayout {
        OffsetLayout {
            offset: 0,
            layout: Layout::zero(),
        }
    }
}

impl fmt::Display for Layout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}/{}", self.size, self.alignment)?;

        if self
            .named_fields
            .as_ref()
            .map(|v| !v.is_empty())
            .unwrap_or(false)
        {
            write!(f, "[")?;

            let mut needs_sep = false;
            for named_field in self.named_fields.as_ref().unwrap() {
                if needs_sep {
                    write!(f, ",")?;
                }
                write!(f, "{:?}:{}", named_field.field, named_field.offset_layout)?;
                needs_sep = true;
            }

            write!(f, "]")?;
        }

        if self
            .unnamed_fields
            .as_ref()
            .map(|v| !v.is_empty())
            .unwrap_or(false)
        {
            write!(f, "[")?;

            let mut needs_sep = false;
            for (idx, offset) in self.unnamed_fields.as_ref().unwrap().iter().enumerate() {
                if needs_sep {
                    write!(f, ",")?;
                }
                write!(f, "{}:{}", idx, offset)?;
                needs_sep = true;
            }

            write!(f, "]")?;
        }

        Ok(())
    }
}

impl fmt::Display for OffsetLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}({})", self.offset, self.layout)
    }
}