taubyte_sdk/storage/content/
seek.rs

1use std::io::Seek;
2
3use crate::storage::Content;
4
5use super::{imports, ReadOnlyContent, ReadWriteContent};
6
7// Implement seek
8impl Seek for Content {
9    fn seek(&mut self, pos: std::io::SeekFrom) -> std::result::Result<u64, std::io::Error> {
10        self.consumed = false;
11
12        let offset: i64;
13        let whence: i32 = match pos {
14            std::io::SeekFrom::Start(start) => {
15                offset = start as i64;
16                0
17            }
18            std::io::SeekFrom::End(end) => {
19                offset = end as i64;
20                2
21            }
22            std::io::SeekFrom::Current(current) => {
23                offset = current as i64;
24                1
25            }
26        };
27        let mut offset_ptr: i32 = 0;
28        #[allow(unused_unsafe)]
29        let err0 = unsafe { imports::contentSeekFile(self.id, offset, whence, &mut offset_ptr) };
30        if err0.is_err() {
31            Err(std::io::Error::new(
32                std::io::ErrorKind::Other,
33                format!("Seeking content failed with: {}", err0),
34            ))
35        } else {
36            Ok(offset_ptr as u64)
37        }
38    }
39}
40
41impl std::io::Seek for ReadWriteContent {
42    fn seek(&mut self, pos: std::io::SeekFrom) -> std::result::Result<u64, std::io::Error> {
43        self.content.seek(pos)
44    }
45}
46
47impl std::io::Seek for ReadOnlyContent {
48    fn seek(&mut self, pos: std::io::SeekFrom) -> std::result::Result<u64, std::io::Error> {
49        self.content.seek(pos)
50    }
51}
52
53#[cfg(test)]
54pub mod test {
55    use std::io::Seek;
56
57    use crate::storage::Content;
58
59    #[test]
60    fn seek() {
61        let mut content = Content::new().unwrap_or_else(|err| {
62            panic!("{}", err);
63        });
64
65        content
66            .seek(std::io::SeekFrom::Start(0))
67            .unwrap_or_else(|err| {
68                panic!("{}", err);
69            });
70    }
71}
72
73#[cfg(test)]
74#[allow(non_snake_case)]
75pub mod mock {
76    use crate::{
77        errno::{Errno, Error},
78        storage::content::new::test as new_test,
79    };
80
81    pub fn contentSeekFile(id: u32, offset: i64, whence: i32, offset_ptr: *mut i32) -> Error {
82        assert_eq!(id, new_test::ID);
83        assert_eq!(offset, 0);
84        assert_eq!(whence, 0);
85        assert_ne!(offset_ptr, std::ptr::null_mut());
86
87        let offset_ptr = unsafe { offset_ptr.as_mut().unwrap() };
88        *offset_ptr = 0;
89
90        Errno::ErrorNone.error()
91    }
92}