pkbuffer/
vec.rs

1use crate::{Buffer, Castable, Error, PtrBuffer, ref_to_bytes, slice_ref_to_bytes};
2
3/// An owned-data [`Buffer`](Buffer) object.
4#[derive(Clone, Eq, Debug)]
5pub struct VecBuffer {
6    data: Vec<u8>,
7}
8impl VecBuffer {
9    /// Create a new ```VecBuffer``` object, similar to [`Vec::new`](Vec::new).
10    pub fn new() -> Self {
11        Self { data: Vec::<u8>::new() }
12    }
13    /// Create a new `VecBuffer` object with initialization data.
14    pub fn from_data<B: AsRef<[u8]>>(data: B) -> Self {
15        Self { data: data.as_ref().to_vec() }
16    }
17    /// Create a new ```VecBuffer``` from the given file data.
18    pub fn from_file<P: AsRef<std::path::Path>>(filename: P) -> Result<Self, Error> {
19        let data = match std::fs::read(filename) {
20            Ok(d) => d,
21            Err(e) => return Err(Error::from(e)),
22        };
23
24        Ok(Self { data })
25    }
26    /// Create a new ```VecBuffer``` with a given starting size. This will zero out the
27    /// buffer on initialization.
28    pub fn with_initial_size(size: usize) -> Self {
29        Self::from_data(&vec![0u8; size])
30    }
31    /// Create a [`PtrBuffer`](PtrBuffer) object from this `VecBuffer` object.
32    pub fn as_ptr_buffer(&self) -> PtrBuffer {
33        PtrBuffer::new(self.data.as_ptr(), self.data.len())
34    }
35    /// Appends the given data to the end of the buffer. This resizes and expands the underlying vector.
36    pub fn append<B: AsRef<[u8]>>(&mut self, data: B) {
37        self.data.append(&mut data.as_ref().to_vec());
38    }
39    /// Appends the given reference to the end of the buffer. This resizes and expands the underlying vector.
40    pub fn append_ref<T: Castable>(&mut self, data: &T) -> Result<(), Error> {
41        let bytes = ref_to_bytes::<T>(data)?;
42        self.append(bytes); Ok(())
43    }
44    /// Appends the given slice reference to the end of the buffer. This resizes and expands the underlying vector.
45    pub fn append_slice_ref<T: Castable>(&mut self, data: &[T]) -> Result<(), Error> {
46        let bytes = slice_ref_to_bytes::<T>(data)?;
47        self.append(bytes); Ok(())
48    }
49    /// Insert a given *element* at the given *offset*, expanding the vector by one. See [`Vec::insert`](Vec::insert).
50    pub fn insert(&mut self, offset: usize, element: u8) {
51        self.data.insert(offset, element);
52    }
53    /// Remove a given element at the given *offset*, shrinking the vector by one. See [`Vec::remove`](Vec::remove).
54    pub fn remove(&mut self, offset: usize) {
55        self.data.remove(offset);
56    }
57    /// Retains only the elements specified by the predicate. See [`Vec::retain`](Vec::retain).
58    pub fn retain<F>(&mut self, f: F)
59    where
60        F: FnMut(&u8) -> bool
61    {
62        self.data.retain(f);
63    }
64    /// Push a byte onto the end of the buffer. See [`Vec::push`](Vec::push).
65    pub fn push(&mut self, v: u8) {
66        self.data.push(v);
67    }
68    /// Pop a byte from the end of the buffer. See [`Vec::pop`](Vec::pop).
69    pub fn pop(&mut self) -> Option<u8> {
70        self.data.pop()
71    }
72    /// Clear the given buffer.
73    pub fn clear(&mut self) {
74        self.data.clear();
75    }
76    /// Split off into another ```VecBuffer``` instance at the given midpoint. See [`Vec::split_off`](Vec::split_off).
77    pub fn split_off(&mut self, at: usize) -> Self {
78        let data = self.data.split_off(at);
79        Self::from_data(&data)
80    }
81    /// Resize the buffer to *new size*, filling with the given closure *f*. See [`Vec::resize_with`](Vec::resize_with).
82    pub fn resize_with<F>(&mut self, new_len: usize, f: F)
83    where
84        F: FnMut() -> u8
85    {
86        self.data.resize_with(new_len, f);
87    }
88    /// Resize the given buffer and fill the void with the given *value*. See [`Vec::resize`](Vec::resize).
89    pub fn resize(&mut self, new_len: usize, value: u8) {
90        self.data.resize(new_len, value);
91    }
92    /// Truncate the size of the buffer to the given *len*.
93    pub fn truncate(&mut self, len: usize) {
94        self.data.truncate(len);
95    }
96    /// Deduplicate the values in this buffer. See [`Vec::dedup`](Vec::dedup).
97    pub fn dedup(&mut self) {
98        self.data.dedup();
99    }
100}
101impl Buffer for VecBuffer {
102    /// Get the length of this `VecBuffer` object.
103    fn len(&self) -> usize {
104        self.data.len()
105    }
106    /// Get the `VecBuffer` object as a pointer.
107    fn as_ptr(&self) -> *const u8 {
108        self.data.as_ptr()
109    }
110    /// Get the `VecBuffer` object as a mutable pointer.
111    fn as_mut_ptr(&mut self) -> *mut u8 {
112        self.data.as_mut_ptr()
113    }
114    /// Get the `VecBuffer` object as a slice.
115    fn as_slice(&self) -> &[u8] {
116        self.data.as_slice()
117    }
118    /// Get the `VecBuffer` object as a mutable slice.
119    fn as_mut_slice(&mut self) -> &mut [u8]
120    {
121        self.data.as_mut_slice()
122    }
123}
124impl PartialEq<[u8]> for VecBuffer {
125    fn eq(&self, other: &[u8]) -> bool {
126        self.as_slice() == other
127    }
128}
129impl<const N: usize> PartialEq<[u8; N]> for VecBuffer {
130    fn eq(&self, other: &[u8; N]) -> bool {
131        self.as_slice() == other
132    }
133}
134impl PartialEq<Vec<u8>> for VecBuffer {
135    fn eq(&self, other: &Vec<u8>) -> bool {
136        self.as_slice() == other.as_slice()
137    }
138}
139impl<T: Buffer> PartialEq<T> for VecBuffer {
140    fn eq(&self, other: &T) -> bool {
141        self.as_slice() == other.as_slice()
142    }
143}
144impl<Idx: std::slice::SliceIndex<[u8]>> std::ops::Index<Idx> for VecBuffer {
145    type Output = Idx::Output;
146
147    fn index(&self, index: Idx) -> &Self::Output {
148        self.data.index(index)
149    }
150}
151impl<Idx: std::slice::SliceIndex<[u8]>> std::ops::IndexMut<Idx> for VecBuffer {
152    fn index_mut(&mut self, index: Idx) -> &mut Self::Output {
153        self.data.index_mut(index)
154    }
155}
156impl std::convert::AsRef<[u8]> for VecBuffer {
157    fn as_ref(&self) -> &[u8] {
158        self.as_slice()
159    }
160}
161impl std::convert::AsMut<[u8]> for VecBuffer {
162    fn as_mut(&mut self) -> &mut [u8] {
163        self.as_mut_slice()
164    }
165}
166impl std::hash::Hash for VecBuffer {
167    fn hash<H>(&self, state: &mut H)
168    where
169        H: std::hash::Hasher
170    {
171        self.data.hash(state);
172    }
173    fn hash_slice<H>(data: &[Self], state: &mut H)
174    where
175        H: std::hash::Hasher
176    {
177        data.iter().for_each(|x| x.hash(state));
178    }
179}
180impl std::iter::IntoIterator for VecBuffer {
181    type Item = u8;
182    type IntoIter = std::vec::IntoIter<Self::Item>;
183
184    fn into_iter(self) -> Self::IntoIter {
185        self.to_vec().into_iter()
186    }
187}
pkbuffer/vec.rs

pkbuffer/
vec.rs
