taubyte_sdk/pubsub/event/
data.rs

1use super::{imports, Event};
2use crate::errno::Error;
3
4impl Event {
5    fn data_size_unsafe(&self, size: *mut usize) -> Error {
6        #[allow(unused_unsafe)]
7        unsafe {
8            imports::getMessageDataSize(self.event, size)
9        }
10    }
11
12    fn data_unsafe(&self, buf_ptr: *mut u8) -> Error {
13        #[allow(unused_unsafe)]
14        unsafe {
15            imports::getMessageData(self.event, buf_ptr)
16        }
17    }
18
19    pub fn data(&self) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
20        let mut size: usize = 0;
21        let err0 = self.data_size_unsafe(&mut size);
22        if err0.is_err() {
23            return Err(format!(
24                "Getting data size for event: `{}` failed with: {}",
25                self.event, err0
26            )
27            .into());
28        }
29        if size == 0 {
30            return Ok(Vec::new());
31        }
32
33        let mut buf = vec![0u8; size];
34        let err0 = self.data_unsafe(buf.as_mut_ptr());
35        if err0.is_err() {
36            Err(format!(
37                "Getting data for event: `{}` failed with: {}",
38                self.event, err0
39            )
40            .into())
41        } else {
42            Ok(buf)
43        }
44    }
45}
46
47#[cfg(test)]
48pub mod test {
49    use crate::pubsub::Event;
50    pub static ID: u32 = 6;
51    pub static DATA: &[u8] = b"testData";
52
53    #[test]
54    fn event_data() {
55        let event = Event { event: ID };
56        let data = event.data().unwrap();
57        assert_eq!(data, DATA);
58    }
59}
60
61#[cfg(test)]
62#[allow(non_snake_case)]
63pub mod mock {
64    use super::test;
65    use crate::{
66        errno::{Errno, Error},
67        utils::test as utils,
68    };
69
70    pub fn getMessageDataSize(event: u32, size: *mut usize) -> Error {
71        if event != test::ID {
72            Errno::ErrorCap.error()
73        } else {
74            utils::write_usize(size, test::DATA.len());
75            Errno::ErrorNone.error()
76        }
77    }
78
79    pub fn getMessageData(event: u32, buf_ptr: *mut u8) -> Error {
80        if event != test::ID {
81            Errno::ErrorCap.error()
82        } else {
83            utils::write_bytes(buf_ptr, test::DATA);
84            Errno::ErrorNone.error()
85        }
86    }
87}