stak_file/file_system/
memory.rs

1use super::utility::decode_path;
2use crate::{FileDescriptor, FileError, FileSystem};
3use heapless::Vec;
4use stak_vm::{Memory, Value};
5
6const PATH_SIZE: usize = 128;
7
8#[derive(Clone, Copy, Debug)]
9pub struct MemoryFileEntry {
10    file_index: usize,
11    offset: usize,
12}
13
14/// A in-memory file system.
15#[derive(Debug)]
16pub struct MemoryFileSystem<'a> {
17    files: &'a [(&'a [u8], &'a [u8])],
18    entries: &'a mut [Option<MemoryFileEntry>],
19}
20
21impl<'a> MemoryFileSystem<'a> {
22    /// Creates a file system.
23    pub const fn new(
24        files: &'a [(&'a [u8], &'a [u8])],
25        entries: &'a mut [Option<MemoryFileEntry>],
26    ) -> Self {
27        Self { files, entries }
28    }
29}
30
31impl FileSystem for MemoryFileSystem<'_> {
32    type Path = [u8];
33    type PathBuf = Vec<u8, PATH_SIZE>;
34    type Error = FileError;
35
36    fn open(&mut self, path: &Self::Path, output: bool) -> Result<FileDescriptor, Self::Error> {
37        if output {
38            return Err(FileError::Open);
39        }
40
41        for (file_index, (file_path, _)) in self.files.iter().enumerate() {
42            if path == *file_path {
43                for (descriptor, entry) in self.entries.iter_mut().enumerate() {
44                    if entry.is_none() {
45                        *entry = Some(MemoryFileEntry {
46                            file_index,
47                            offset: 0,
48                        });
49
50                        return Ok(descriptor);
51                    }
52                }
53            }
54        }
55
56        Err(FileError::Open)
57    }
58
59    fn close(&mut self, descriptor: FileDescriptor) -> Result<(), Self::Error> {
60        let Some(entry) = self.entries.get_mut(descriptor) else {
61            return Err(FileError::Close);
62        };
63
64        *entry = None;
65
66        Ok(())
67    }
68
69    fn read(&mut self, descriptor: FileDescriptor) -> Result<u8, Self::Error> {
70        let entry = &mut self
71            .entries
72            .get_mut(descriptor)
73            .and_then(Option::as_mut)
74            .ok_or(FileError::Read)?;
75
76        let byte = self
77            .files
78            .get(entry.file_index)
79            .ok_or(FileError::Read)?
80            .1
81            .get(entry.offset)
82            .ok_or(FileError::Read)?;
83
84        entry.offset += 1;
85
86        Ok(*byte)
87    }
88
89    fn write(&mut self, _: FileDescriptor, _: u8) -> Result<(), Self::Error> {
90        Err(FileError::Write)
91    }
92
93    fn delete(&mut self, _: &Self::Path) -> Result<(), Self::Error> {
94        Err(FileError::Delete)
95    }
96
97    fn flush(&mut self, _: FileDescriptor) -> Result<(), Self::Error> {
98        Err(FileError::Flush)
99    }
100
101    fn exists(&self, path: &Self::Path) -> Result<bool, Self::Error> {
102        for (file_path, _) in self.files {
103            if &path == file_path {
104                return Ok(true);
105            }
106        }
107
108        Ok(false)
109    }
110
111    fn decode_path(memory: &Memory, list: Value) -> Result<Self::PathBuf, Self::Error> {
112        decode_path(memory, list).ok_or(FileError::PathDecode)
113    }
114}
115
116#[cfg(test)]
117mod tests {
118    use super::*;
119
120    #[test]
121    fn create_file_system() {
122        MemoryFileSystem::new(&[], &mut []);
123    }
124
125    #[test]
126    fn read() {
127        let mut entries = [Default::default(); 8];
128        let mut system = MemoryFileSystem::new(&[(b"foo", b"bar")], &mut entries);
129
130        let descriptor = system.open(b"foo", false).unwrap();
131
132        assert_eq!(system.read(descriptor), Ok(b'b'));
133        assert_eq!(system.read(descriptor), Ok(b'a'));
134        assert_eq!(system.read(descriptor), Ok(b'r'));
135        assert!(system.read(descriptor).is_err());
136
137        system.close(descriptor).unwrap();
138
139        assert!(system.read(descriptor).is_err());
140    }
141
142    #[test]
143    fn exists() {
144        let mut entries = [Default::default(); 8];
145        let system = MemoryFileSystem::new(&[(b"foo", b"bar")], &mut entries);
146
147        assert!(system.exists(b"foo").unwrap());
148        assert!(!system.exists(b"bar").unwrap());
149    }
150}
stak_file/file_system/memory.rs

stak_file/file_system/
memory.rs
