burn_dragon_core 0.5.0

burn dragon core model and utilities
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

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StructuredBankRole {
    Primary,
    Context,
    Global,
}

impl StructuredBankRole {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Primary => "primary",
            Self::Context => "context",
            Self::Global => "global",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StructuredRouteOperation {
    Read,
    Write,
}

impl StructuredRouteOperation {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Read => "read",
            Self::Write => "write",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StructuredRoutePattern {
    Identity,
    Local,
    Pool,
    Broadcast,
    Sparse,
    Dense,
    Grouped,
}

impl StructuredRoutePattern {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Identity => "identity",
            Self::Local => "local",
            Self::Pool => "pool",
            Self::Broadcast => "broadcast",
            Self::Sparse => "sparse",
            Self::Dense => "dense",
            Self::Grouped => "grouped",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub struct StructuredRouteSpec {
    pub source: StructuredBankRole,
    pub target: StructuredBankRole,
    pub operation: StructuredRouteOperation,
    pub pattern: StructuredRoutePattern,
}

impl StructuredRouteSpec {
    pub const fn new(
        source: StructuredBankRole,
        target: StructuredBankRole,
        operation: StructuredRouteOperation,
        pattern: StructuredRoutePattern,
    ) -> Self {
        Self {
            source,
            target,
            operation,
            pattern,
        }
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct StructuredRoutingSpec {
    routes: Vec<StructuredRouteSpec>,
}

impl StructuredRoutingSpec {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn routes(&self) -> &[StructuredRouteSpec] {
        &self.routes
    }

    pub fn with_route(mut self, route: StructuredRouteSpec) -> Self {
        self.routes.push(route);
        self
    }

    pub fn contains(&self, route: StructuredRouteSpec) -> bool {
        self.routes.contains(&route)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn routing_spec_tracks_routes() {
        let route = StructuredRouteSpec::new(
            StructuredBankRole::Primary,
            StructuredBankRole::Context,
            StructuredRouteOperation::Write,
            StructuredRoutePattern::Pool,
        );
        let spec = StructuredRoutingSpec::new().with_route(route);
        assert!(spec.contains(route));
        assert_eq!(spec.routes().len(), 1);
        assert_eq!(spec.routes()[0].pattern.as_str(), "pool");
    }
}