xref: /DragonOS/kernel/src/libs/vec_cursor.rs (revision b5b571e02693d91eb6918d3b7561e088c3e7ee81) ! 
1 #![allow(dead_code)]
2 
3 use core::mem::{size_of, size_of_val};
4 
5 use alloc::vec::Vec;
6 use system_error::SystemError;
7 
8 use crate::driver::base::block::SeekFrom;
9 
10 /// @brief 本模块用于为数组提供游标的功能，以简化其操作。
11 #[derive(Debug)]
12 pub struct VecCursor {
13     /// 游标管理的数据
14     data: Vec<u8>,
15     /// 游标的位置
16     pos: usize,
17 }
18 
19 impl VecCursor {
20     /// @brief 新建一个游标
new(data: Vec<u8>) -> Self21     pub fn new(data: Vec<u8>) -> Self {
22         return Self { data, pos: 0 };
23     }
24 
25     /// @brief 创建一个全0的cursor
zerod(length: usize) -> Self26     pub fn zerod(length: usize) -> Self {
27         let mut result = VecCursor {
28             data: Vec::new(),
29             pos: 0,
30         };
31         result.data.resize(length, 0);
32         return result;
33     }
34 
35     /// @brief 获取游标管理的数据的可变引用
get_mut(&mut self) -> &mut Vec<u8>36     pub fn get_mut(&mut self) -> &mut Vec<u8> {
37         return &mut self.data;
38     }
39 
40     /// @brief 获取游标管理的数据的不可变引用
get_ref(&self) -> &Vec<u8>41     pub fn get_ref(&self) -> &Vec<u8> {
42         return &self.data;
43     }
44 
45     /// @brief 读取一个u8的数据（小端对齐）
read_u8(&mut self) -> Result<u8, SystemError>46     pub fn read_u8(&mut self) -> Result<u8, SystemError> {
47         if self.pos >= self.data.len() {
48             return Err(SystemError::E2BIG);
49         }
50         self.pos += 1;
51         return Ok(self.data[self.pos - 1]);
52     }
53 
54     /// @brief 读取一个u16的数据（小端对齐）
read_u16(&mut self) -> Result<u16, SystemError>55     pub fn read_u16(&mut self) -> Result<u16, SystemError> {
56         if self.pos + 2 > self.data.len() {
57             return Err(SystemError::E2BIG);
58         }
59         let mut res = 0u16;
60         res |= (self.data[self.pos] as u16) & 0xff;
61         self.pos += 1;
62         res |= ((self.data[self.pos] as u16) & 0xff) << 8;
63         self.pos += 1;
64 
65         return Ok(res);
66     }
67 
68     /// @brief 读取一个u32的数据（小端对齐）
read_u32(&mut self) -> Result<u32, SystemError>69     pub fn read_u32(&mut self) -> Result<u32, SystemError> {
70         if self.pos + 4 > self.data.len() {
71             return Err(SystemError::E2BIG);
72         }
73         let mut res = 0u32;
74         for i in 0..4 {
75             res |= ((self.data[self.pos] as u32) & 0xff) << (8 * i);
76             self.pos += 1;
77         }
78 
79         return Ok(res);
80     }
81 
82     /// @brief 读取一个u64的数据（小端对齐）
read_u64(&mut self) -> Result<u64, SystemError>83     pub fn read_u64(&mut self) -> Result<u64, SystemError> {
84         if self.pos + 8 > self.data.len() {
85             return Err(SystemError::E2BIG);
86         }
87         let mut res = 0u64;
88         for i in 0..8 {
89             res |= ((self.data[self.pos] as u64) & 0xff) << (8 * i);
90             self.pos += 1;
91         }
92 
93         return Ok(res);
94     }
95 
96     /// @brief 精确读取与buf同样大小的数据。
97     ///
98     /// @param buf 要读取到的目标缓冲区
99     ///
100     /// @return Ok(()) 成功读取
101     /// @retunr Err(-E2BIG) 没有这么多数据，读取失败
read_exact(&mut self, buf: &mut [u8]) -> Result<(), SystemError>102     pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), SystemError> {
103         if self.pos + buf.len() > self.data.len() {
104             return Err(SystemError::E2BIG);
105         }
106         buf.copy_from_slice(&self.data[self.pos..self.pos + buf.len()]);
107         self.pos += buf.len();
108         return Ok(());
109     }
110 
111     /// @brief 小端对齐，读取数据到u16数组.
112     ///
113     /// @param buf 目标u16数组
read_u16_into(&mut self, buf: &mut [u16]) -> Result<(), SystemError>114     pub fn read_u16_into(&mut self, buf: &mut [u16]) -> Result<(), SystemError> {
115         if self.pos + size_of_val(buf) > self.data.len() * size_of::<u16>() {
116             return Err(SystemError::E2BIG);
117         }
118 
119         for item in buf.iter_mut() {
120             *item = self.read_u16()?;
121         }
122 
123         return Ok(());
124     }
125 
126     /// @brief 调整游标的位置
127     ///
128     /// @param 调整的相对值
129     ///
130     /// @return Ok(新的游标位置) 调整成功，返回新的游标位置
131     /// @return Err(SystemError::EOVERFLOW) 调整失败，游标超出正确的范围。（失败时游标位置不变）
seek(&mut self, origin: SeekFrom) -> Result<usize, SystemError>132     pub fn seek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
133         let pos = match origin {
134             SeekFrom::SeekSet(offset) => offset,
135             SeekFrom::SeekCurrent(offset) => self.pos as i64 + offset,
136             // 请注意，此处的offset应小于等于0，否则肯定是不合法的
137             SeekFrom::SeekEnd(offset) => self.data.len() as i64 + offset,
138             SeekFrom::Invalid => {
139                 return Err(SystemError::EINVAL);
140             }
141         };
142 
143         if pos < 0 || pos > self.data.len() as i64 {
144             return Err(SystemError::EOVERFLOW);
145         }
146         self.pos = pos as usize;
147         return Ok(self.pos);
148     }
149 
150     /// @brief 写入一个u8的数据（小端对齐）
write_u8(&mut self, value: u8) -> Result<u8, SystemError>151     pub fn write_u8(&mut self, value: u8) -> Result<u8, SystemError> {
152         if self.pos >= self.data.len() {
153             return Err(SystemError::E2BIG);
154         }
155 
156         self.data[self.pos] = value;
157         self.pos += 1;
158 
159         return Ok(value);
160     }
161 
162     /// @brief 写入一个u16的数据（小端对齐）
write_u16(&mut self, value: u16) -> Result<u16, SystemError>163     pub fn write_u16(&mut self, value: u16) -> Result<u16, SystemError> {
164         if self.pos + 2 > self.data.len() {
165             return Err(SystemError::E2BIG);
166         }
167 
168         self.data[self.pos] = (value & 0xff) as u8;
169         self.pos += 1;
170         self.data[self.pos] = ((value >> 8) & 0xff) as u8;
171         self.pos += 1;
172 
173         return Ok(value);
174     }
175 
176     /// @brief 写入一个u32的数据（小端对齐）
write_u32(&mut self, value: u32) -> Result<u32, SystemError>177     pub fn write_u32(&mut self, value: u32) -> Result<u32, SystemError> {
178         if self.pos + 4 > self.data.len() {
179             return Err(SystemError::E2BIG);
180         }
181 
182         for i in 0..4 {
183             self.data[self.pos] = ((value >> (i * 8)) & 0xff) as u8;
184             self.pos += 1;
185         }
186 
187         return Ok(value);
188     }
189 
190     /// @brief 写入一个u64的数据（小端对齐）
write_u64(&mut self, value: u64) -> Result<u64, SystemError>191     pub fn write_u64(&mut self, value: u64) -> Result<u64, SystemError> {
192         if self.pos + 8 > self.data.len() {
193             return Err(SystemError::E2BIG);
194         }
195 
196         for i in 0..8 {
197             self.data[self.pos] = ((value >> (i * 8)) & 0xff) as u8;
198             self.pos += 1;
199         }
200 
201         return Ok(value);
202     }
203 
204     /// @brief 精确写入与buf同样大小的数据。
205     ///
206     /// @param buf 要写入到的目标缓冲区
207     ///
208     /// @return Ok(()) 成功写入
209     /// @retunr Err(-E2BIG) 没有这么多数据，写入失败
write_exact(&mut self, buf: &[u8]) -> Result<(), SystemError>210     pub fn write_exact(&mut self, buf: &[u8]) -> Result<(), SystemError> {
211         if self.pos + buf.len() > self.data.len() {
212             return Err(SystemError::E2BIG);
213         }
214 
215         self.data[self.pos..self.pos + buf.len()].copy_from_slice(buf);
216         self.pos += buf.len();
217 
218         return Ok(());
219     }
220 
221     /// @brief 获取当前的数据切片
as_slice(&self) -> &[u8]222     pub fn as_slice(&self) -> &[u8] {
223         return &self.data[..];
224     }
225 
226     /// @brief 获取可变数据切片
as_mut_slice(&mut self) -> &mut [u8]227     pub fn as_mut_slice(&mut self) -> &mut [u8] {
228         return &mut self.data[..];
229     }
230 
231     /// @brief 获取当前游标的位置
232     #[inline]
pos(&self) -> usize233     pub fn pos(&self) -> usize {
234         return self.pos;
235     }
236 
237     /// @brief 获取缓冲区数据的大小
238     #[inline]
len(&self) -> usize239     pub fn len(&self) -> usize {
240         return self.data.len();
241     }
242 }
243