1use core::cmp::min;
2use core::fmt;
3
4use crate::error::RnsError;
5
6#[derive(Debug, PartialEq, Eq, Copy, Clone)]
7pub struct StaticBuffer<const N: usize> {
8 buffer: [u8; N],
9 len: usize,
10}
11
12impl<const N: usize> StaticBuffer<N> {
13 pub const fn new() -> Self {
14 Self { buffer: [0u8; N], len: 0 }
15 }
16
17 pub fn new_from_slice(data: &[u8]) -> Self {
18 let mut buffer = Self::new();
19
20 buffer.safe_write(data);
21
22 buffer
23 }
24
25 pub fn reset(&mut self) {
26 self.len = 0;
27 }
28
29 pub fn resize(&mut self, len: usize) {
30 self.len = min(len, self.buffer.len());
31 }
32
33 pub fn len(&self) -> usize {
34 self.len
35 }
36
37 pub fn is_empty(&self) -> bool {
38 self.len == 0
39 }
40
41 pub fn chain_write(&mut self, data: &[u8]) -> Result<&mut Self, RnsError> {
42 self.write(data)?;
43 Ok(self)
44 }
45
46 pub fn finalize(self) -> Self {
47 self
48 }
49
50 pub fn safe_write(&mut self, data: &[u8]) -> usize {
51 let data_size = data.len();
52
53 let max_size = core::cmp::min(data_size, N - self.len);
54
55 self.write(&data[..max_size]).unwrap_or(0)
56 }
57
58 pub fn chain_safe_write(&mut self, data: &[u8]) -> &mut Self {
59 self.safe_write(data);
60 self
61 }
62
63 pub fn write(&mut self, data: &[u8]) -> Result<usize, RnsError> {
64 let data_size = data.len();
65
66 if data_size == 0 {
68 return Ok(0);
69 }
70
71 if (self.len + data_size) > N {
72 return Err(RnsError::OutOfMemory);
73 }
74
75 self.buffer[self.len..(self.len + data_size)].copy_from_slice(data);
76 self.len += data_size;
77
78 Ok(data_size)
79 }
80
81 pub fn rotate_left(&mut self, mid: usize) -> Result<usize, RnsError> {
82 if mid > self.len {
83 return Err(RnsError::InvalidArgument);
84 }
85
86 self.len -= mid;
87
88 self.buffer.rotate_left(mid);
89
90 Ok(self.len)
91 }
92
93 pub fn as_slice(&self) -> &[u8] {
94 &self.buffer[..self.len]
95 }
96
97 pub fn as_mut_slice(&mut self) -> &mut [u8] {
98 &mut self.buffer[..self.len]
99 }
100
101 pub fn accuire_buf(&mut self, len: usize) -> &mut [u8] {
102 self.len = len;
103 &mut self.buffer[..self.len]
104 }
105
106 pub fn accuire_buf_max(&mut self) -> &mut [u8] {
107 self.len = self.buffer.len();
108 &mut self.buffer[..self.len]
109 }
110}
111
112impl<const N: usize> Default for StaticBuffer<N> {
113 fn default() -> Self {
114 Self { buffer: [0u8; N], len: 0 }
115 }
116}
117
118pub struct OutputBuffer<'a> {
119 buffer: &'a mut [u8],
120 offset: usize,
121}
122
123impl<'a> OutputBuffer<'a> {
124 pub fn new(buffer: &'a mut [u8]) -> Self {
125 Self { offset: 0, buffer }
126 }
127
128 pub fn write(&mut self, data: &[u8]) -> Result<usize, RnsError> {
129 let data_size = data.len();
130
131 if data_size == 0 {
133 return Ok(0);
134 }
135
136 if (self.offset + data_size) > self.buffer.len() {
137 return Err(RnsError::OutOfMemory);
138 }
139
140 self.buffer[self.offset..(self.offset + data_size)].copy_from_slice(data);
141 self.offset += data_size;
142
143 Ok(data_size)
144 }
145
146 pub fn write_byte(&mut self, byte: u8) -> Result<usize, RnsError> {
147 self.write(&[byte])
148 }
149
150 pub fn reset(&mut self) {
151 self.offset = 0;
152 }
153
154 pub fn is_full(&self) -> bool {
155 self.offset == self.buffer.len()
156 }
157
158 pub fn offset(&self) -> usize {
159 self.offset
160 }
161
162 pub fn as_slice(&self) -> &[u8] {
163 &self.buffer[..self.offset]
164 }
165
166 pub fn as_mut_slice(&mut self) -> &mut [u8] {
167 &mut self.buffer[..self.offset]
168 }
169}
170
171impl<'a> fmt::Display for OutputBuffer<'a> {
172 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
173 write!(f, "[ 0x")?;
174
175 for i in 0..self.offset {
176 write!(f, "{:0>2x}", self.buffer[i])?;
177 }
178
179 write!(f, " ]",)
180 }
181}
182
183impl<const N: usize> fmt::Display for StaticBuffer<N> {
184 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
185 write!(f, "[ 0x")?;
186
187 for i in 0..self.len {
188 write!(f, "{:0>2x}", self.buffer[i])?;
189 }
190
191 write!(f, " ]",)
192 }
193}
194
195pub struct InputBuffer<'a> {
196 buffer: &'a [u8],
197 offset: usize,
198}
199
200impl<'a> InputBuffer<'a> {
201 pub fn new(buffer: &'a [u8]) -> Self {
202 Self { offset: 0, buffer }
203 }
204
205 pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, RnsError> {
206 let size = buf.len();
207 if (self.offset + size) > self.buffer.len() {
208 return Err(RnsError::OutOfMemory);
209 }
210
211 buf.copy_from_slice(&self.buffer[self.offset..(self.offset + size)]);
212 self.offset += size;
213
214 Ok(size)
215 }
216
217 pub fn read_size(&mut self, buf: &mut [u8], size: usize) -> Result<usize, RnsError> {
218 if (self.offset + size) > self.buffer.len() {
219 return Err(RnsError::OutOfMemory);
220 }
221
222 if buf.len() < size {
223 return Err(RnsError::OutOfMemory);
224 }
225
226 buf[..size].copy_from_slice(&self.buffer[self.offset..(self.offset + size)]);
227 self.offset += size;
228
229 Ok(size)
230 }
231
232 pub fn read_byte(&mut self) -> Result<u8, RnsError> {
233 let mut buf = [0u8; 1];
234 self.read(&mut buf)?;
235
236 Ok(buf[0])
237 }
238
239 pub fn read_slice(&mut self, size: usize) -> Result<&[u8], RnsError> {
240 if (self.offset + size) > self.buffer.len() {
241 return Err(RnsError::OutOfMemory);
242 }
243
244 let slice = &self.buffer[self.offset..self.offset + size];
245
246 self.offset += size;
247
248 Ok(slice)
249 }
250
251 pub fn bytes_left(&self) -> usize {
252 self.buffer.len() - self.offset
253 }
254}