taubyte_sdk/storage/content/
write.rs

1use std::io::Write;
2
3use crate::storage::Content;
4
5use super::{imports, ReadWriteContent};
6
7impl Write for Content {
8    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
9        let mut count: usize = 0;
10        #[allow(unused_unsafe)]
11        let err0 =
12            unsafe { imports::contentWriteFile(self.id, buf.as_ptr(), buf.len(), &mut count) };
13        if err0.is_err() {
14            Err(std::io::Error::new(
15                std::io::ErrorKind::Other,
16                format!("Writing content failed with: {}", err0),
17            ))
18        } else {
19            Ok(count)
20        }
21    }
22
23    fn flush(&mut self) -> std::io::Result<()> {
24        // TODO implement
25        Ok(())
26    }
27}
28
29impl Write for ReadWriteContent {
30    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
31        self.content.write(buf)
32    }
33
34    fn flush(&mut self) -> std::io::Result<()> {
35        self.content.flush()
36    }
37}
38
39#[cfg(test)]
40pub mod test {
41    use crate::storage::Content;
42    use std::io::Write;
43
44    pub static EXPECTED_WRITE: &str = "Hello, world!";
45
46    #[test]
47    fn write() {
48        let mut content = Content::new().unwrap_or_else(|err| {
49            panic!("{}", err);
50        });
51
52        content
53            .write_all(EXPECTED_WRITE.as_bytes())
54            .unwrap_or_else(|err| {
55                panic!("{}", err);
56            });
57    }
58}
59
60#[cfg(test)]
61#[allow(non_snake_case)]
62pub mod mock {
63    use super::test;
64
65    use crate::{
66        errno::{Errno, Error},
67        storage::content::new::test as new_test,
68        utils::test as utils,
69    };
70
71    pub fn contentWriteFile(
72        id: u32,
73        buf_ptr: *const u8,
74        buf_size: usize,
75        count: *mut usize,
76    ) -> Error {
77        if id != new_test::ID {
78            return Errno::ErrorCap.error();
79        }
80
81        unsafe {
82            let result = utils::read_string(buf_ptr, buf_size);
83            if result != test::EXPECTED_WRITE {
84                return Errno::ErrorCap.error();
85            }
86
87            *count = buf_size;
88        }
89
90        Errno::ErrorNone.error()
91    }
92}