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