gc_abi 0.5.0

Gridcore Plugin Safe ABI Bindings
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
137
138
139
140
141
142

use crate::{GCAbiConversion, GCDatapointID};
use std::{
    ffi::{CStr, CString, c_char},
    fmt::Debug,
};

/// Safe zero cost abstraction over the [gc_abi_sys::GCDatapoint]
/// This struct is meant to be initialized only by the gateway or another internal module.
#[repr(transparent)]
pub struct GCDatapoint(gc_abi_sys::GCDatapoint);

impl GCDatapoint {
    pub fn new(id: GCDatapointID, name: &str, description: &str, unit: &str) -> GCDatapoint {
        GCDatapoint(gc_abi_sys::GCDatapoint {
            id,
            name: CString::new(name).unwrap().into_raw(),
            description: CString::new(description).unwrap().into_raw(),
            unit: CString::new(unit).unwrap().into_raw(),
        })
    }

    /// Get the CStr representation of the name
    #[inline]
    pub fn get_c_name(&self) -> &CStr {
        // Safety:
        // The pointer is guaranteed to be valid by the gateway core
        unsafe { CStr::from_ptr(self.0.name) }
    }

    /// Get the CStr representation of the description
    #[inline]
    pub fn get_c_description(&self) -> &CStr {
        // Safety:
        // The pointer is guaranteed to be valid by the gateway core
        unsafe { CStr::from_ptr(self.0.description) }
    }

    /// Get the CStr representation of the unit
    #[inline]
    pub fn get_c_unit(&self) -> &CStr {
        // Safety:
        // The pointer is guaranteed to be valid by the gateway core
        unsafe { CStr::from_ptr(self.0.unit) }
    }

    /// Get the name as a native String
    #[inline]
    pub fn get_name(&self) -> String {
        self.get_c_name().to_string_lossy().into_owned()
    }

    /// Get the description as a native String
    #[inline]
    pub fn get_description(&self) -> String {
        self.get_c_description().to_string_lossy().into_owned()
    }

    /// Get the unit as a native String
    #[inline]
    pub fn get_unit(&self) -> String {
        self.get_c_unit().to_string_lossy().into_owned()
    }

    /// Get the ID of the datapoint
    #[inline]
    pub fn get_id(&self) -> GCDatapointID {
        self.0.id
    }
}

impl Debug for GCDatapoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("GCDatapoint")
            .field("id", &self.get_id())
            .field("name", &self.get_name())
            .field("description", &self.get_description())
            .field("unit", &self.get_unit())
            .finish()
    }
}

impl Drop for GCDatapoint {
    fn drop(&mut self) {
        unsafe {
            drop(CString::from_raw(self.0.name as *mut c_char));
            drop(CString::from_raw(self.0.description as *mut c_char));
            drop(CString::from_raw(self.0.unit as *mut c_char));
        }
    }
}

unsafe impl GCAbiConversion for GCDatapoint {
    type CType = gc_abi_sys::GCDatapoint;

    fn from_c(c_type: Self::CType) -> Self {
        GCDatapoint(c_type)
    }

    fn into_c(self) -> Self::CType {
        self.0
    }
}

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

    #[test]
    fn test_c_conversion() {
        let c_datapoint = gc_abi_sys::GCDatapoint {
            id: 0,
            name: CString::new("test").unwrap().into_raw(),
            description: CString::new("test").unwrap().into_raw(),
            unit: CString::new("test").unwrap().into_raw(),
        };

        let datapoint: GCDatapoint = GCDatapoint::from_c(c_datapoint);

        assert_eq!(datapoint.get_id(), 0);
        assert_eq!(datapoint.get_c_name().to_str().unwrap(), "test");
        assert_eq!(datapoint.get_c_description().to_str().unwrap(), "test");
        assert_eq!(datapoint.get_c_unit().to_str().unwrap(), "test");

        assert_eq!(datapoint.get_name(), "test");
        assert_eq!(datapoint.get_description(), "test");
        assert_eq!(datapoint.get_unit(), "test");
    }

    #[test]
    fn test_data_point_create() {
        let datapoint = GCDatapoint::new(0, "test", "test", "test");

        assert_eq!(datapoint.get_id(), 0);
        assert_eq!(datapoint.get_c_name().to_str().unwrap(), "test");
        assert_eq!(datapoint.get_c_description().to_str().unwrap(), "test");
        assert_eq!(datapoint.get_c_unit().to_str().unwrap(), "test");

        assert_eq!(datapoint.get_name(), "test");
        assert_eq!(datapoint.get_description(), "test");
        assert_eq!(datapoint.get_unit(), "test");
    }
}