tin-lang 0.2.2

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

use std::collections;
use std::fmt;

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

#[derive(Clone, Component, Debug, VisitEntities)]
#[storage(VecStorage)]
pub struct Layout {
    pub size: usize,
    pub alignment: usize,
    pub named_field_offsets: Option<collections::HashMap<String, usize>>,
    pub unnamed_field_offsets: Option<Vec<usize>>,
}

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

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

    pub fn named_fields(
        size: usize,
        alignment: usize,
        named_field_offsets: collections::HashMap<String, usize>,
    ) -> Layout {
        let named_field_offsets = Some(named_field_offsets);
        let unnamed_field_offsets = None;

        Layout {
            size,
            alignment,
            named_field_offsets,
            unnamed_field_offsets,
        }
    }

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

        Layout {
            size,
            alignment,
            named_field_offsets,
            unnamed_field_offsets,
        }
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}