oxictl 0.1.1

Pure Rust Real-Time Control Systems Framework
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

//! oxirs knowledge graph bridge (stub).
//!
//! Integration point for connecting oxictl to the oxirs knowledge graph
//! and symbolic reasoning ecosystem.
//!
//! Exposes a trait for querying and updating symbolic state (e.g. equipment
//! status, process tags, alarm states) from within control loops.

/// A symbolic tag value — scalar, boolean, or enumerated.
#[derive(Debug, Clone)]
pub enum TagValue {
    /// Floating-point measurement.
    Real(f64),
    /// Boolean flag.
    Bool(bool),
    /// Integer enum (maps to named state in the knowledge graph).
    Enum(u32),
    /// Unavailable / unknown.
    Unavailable,
}

/// A knowledge graph tag descriptor.
#[derive(Debug, Clone)]
pub struct Tag {
    pub id: u32,
    pub name: &'static str,
    pub value: TagValue,
    pub timestamp_us: u64,
}

/// Trait for oxirs-compatible knowledge graph interfaces.
pub trait OxirsInterface {
    /// Query a tag by ID. Returns None if not found.
    fn query_tag(&self, tag_id: u32) -> Option<&Tag>;

    /// Update a tag value.
    fn update_tag(&mut self, tag_id: u32, value: TagValue, timestamp_us: u64) -> bool;

    /// Check if the knowledge graph is available.
    fn is_available(&self) -> bool;
}

/// Stub oxirs interface backed by a fixed-size tag array.
pub struct NullOxirsInterface<const N: usize> {
    tags: [Option<Tag>; N],
}

impl<const N: usize> NullOxirsInterface<N> {
    pub fn new() -> Self {
        Self {
            tags: core::array::from_fn(|_| None),
        }
    }

    /// Pre-populate a tag slot.
    pub fn define_tag(&mut self, slot: usize, id: u32, name: &'static str) {
        if slot < N {
            self.tags[slot] = Some(Tag {
                id,
                name,
                value: TagValue::Unavailable,
                timestamp_us: 0,
            });
        }
    }
}

impl<const N: usize> Default for NullOxirsInterface<N> {
    fn default() -> Self {
        Self::new()
    }
}

impl<const N: usize> OxirsInterface for NullOxirsInterface<N> {
    fn query_tag(&self, tag_id: u32) -> Option<&Tag> {
        self.tags
            .iter()
            .filter_map(|t| t.as_ref())
            .find(|t| t.id == tag_id)
    }

    fn update_tag(&mut self, tag_id: u32, value: TagValue, timestamp_us: u64) -> bool {
        for tag in self.tags.iter_mut().flatten() {
            if tag.id == tag_id {
                tag.value = value;
                tag.timestamp_us = timestamp_us;
                return true;
            }
        }
        false
    }

    fn is_available(&self) -> bool {
        true
    }
}

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

    #[test]
    fn define_and_query_tag() {
        let mut iface = NullOxirsInterface::<8>::new();
        iface.define_tag(0, 42, "temperature");
        let tag = iface.query_tag(42).unwrap();
        assert_eq!(tag.name, "temperature");
        assert!(matches!(tag.value, TagValue::Unavailable));
    }

    #[test]
    fn update_tag_value() {
        let mut iface = NullOxirsInterface::<4>::new();
        iface.define_tag(0, 1, "pressure");
        assert!(iface.update_tag(1, TagValue::Real(101.325), 1000));
        let tag = iface.query_tag(1).unwrap();
        if let TagValue::Real(v) = tag.value {
            assert!((v - 101.325).abs() < 1e-10);
        } else {
            panic!("Expected Real");
        }
    }

    #[test]
    fn query_missing_tag_returns_none() {
        let iface = NullOxirsInterface::<4>::new();
        assert!(iface.query_tag(999).is_none());
    }

    #[test]
    fn update_missing_tag_returns_false() {
        let mut iface = NullOxirsInterface::<4>::new();
        assert!(!iface.update_tag(999, TagValue::Bool(true), 0));
    }
}