zhc_ir 0.1.8

Graph-based intermediate representation framework with dialect support
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

use std::{cell::RefCell, fmt::Display, rc::Rc};
use zhc_utils::{
    fsm,
    graphics::{Frame, Size},
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Solution {
    pub size: Size,
    pub frame: Frame,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VariableCell(Rc<RefCell<Variable>>);

impl VariableCell {
    pub fn fresh() -> Self {
        VariableCell(Rc::new(RefCell::new(Variable::Fresh)))
    }
}

impl VariableCell {
    pub fn set_size(&mut self, size: Size) {
        self.0.borrow_mut().set_size(size);
    }

    pub fn set_frame(&mut self, frame: Frame) {
        self.0.borrow_mut().set_frame(frame);
    }

    pub fn get_size(&self) -> Size {
        self.0.borrow().get_size()
    }

    pub fn get_frame(&self) -> Frame {
        self.0.borrow().get_frame()
    }

    pub fn get_solution(&self) -> Solution {
        self.0.borrow().get_solution()
    }
}

impl Display for VariableCell {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ptr_str = format!("{:p}", self.0.as_ptr());
        let last_4 = &ptr_str[ptr_str.len().saturating_sub(4)..];
        write!(f, "#{}", last_4)
    }
}

/// Tracks the layout computation state of an element through the sizing and positioning phases.
#[fsm]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Variable {
    Fresh,
    Sized { size: Size },
    Framed { size: Size, frame: Frame },
}

impl Variable {
    /// Transitions from Fresh to Sized state with the computed size.
    pub fn set_size(&mut self, size: Size) {
        self.transition(|old| {
            let Variable::Fresh = old else { panic!() };
            Variable::Sized { size }
        });
    }

    /// Transitions from Sized to Framed state with the final positioned frame.
    pub fn set_frame(&mut self, frame: Frame) {
        self.transition(|old| {
            let Variable::Sized { size } = old else {
                panic!()
            };
            Variable::Framed { size, frame }
        });
    }

    /// Returns the computed size after the sizing phase.
    pub fn get_size(&self) -> Size {
        match self {
            Self::Sized { size, .. } | Self::Framed { size, .. } => size.clone(),
            _ => panic!(),
        }
    }

    /// Returns the final positioned frame after the positioning phase.
    pub fn get_frame(&self) -> Frame {
        match self {
            Self::Framed { frame, .. } => frame.clone(),
            _ => panic!(),
        }
    }

    pub fn get_solution(&self) -> Solution {
        match self {
            Self::Framed { frame, size } => Solution {
                frame: frame.clone(),
                size: size.clone(),
            },
            _ => panic!(),
        }
    }
}