1 use { 2 super::bytes_errors::{BytesReadError, BytesReadErrorValue}, 3 byteorder::{ByteOrder, ReadBytesExt}, 4 bytes::{BufMut, BytesMut}, 5 std::io::Cursor, 6 }; 7 8 pub struct BytesReader { 9 buffer: BytesMut, 10 } 11 impl BytesReader { 12 pub fn new(input: BytesMut) -> Self { 13 Self { buffer: input } 14 } 15 16 pub fn extend_from_slice(&mut self, extend: &[u8]) { 17 let remaining_mut = self.buffer.remaining_mut(); 18 let extend_length = extend.len(); 19 20 if extend_length > remaining_mut { 21 let additional = extend_length - remaining_mut; 22 self.buffer.reserve(additional); 23 } 24 25 self.buffer.extend_from_slice(extend) 26 } 27 28 pub fn read_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> { 29 if self.buffer.len() < bytes_num { 30 return Err(BytesReadError { 31 value: BytesReadErrorValue::NotEnoughBytes, 32 }); 33 } 34 Ok(self.buffer.split_to(bytes_num)) 35 } 36 37 pub fn advance_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> { 38 if self.buffer.len() < bytes_num { 39 return Err(BytesReadError { 40 value: BytesReadErrorValue::NotEnoughBytes, 41 }); 42 } 43 44 //here maybe optimised 45 Ok(self.buffer.clone().split_to(bytes_num)) 46 } 47 48 pub fn read_bytes_cursor( 49 &mut self, 50 bytes_num: usize, 51 ) -> Result<Cursor<BytesMut>, BytesReadError> { 52 let tmp_bytes = self.read_bytes(bytes_num)?; 53 let tmp_cursor = Cursor::new(tmp_bytes); 54 Ok(tmp_cursor) 55 } 56 57 pub fn advance_bytes_cursor( 58 &mut self, 59 bytes_num: usize, 60 ) -> Result<Cursor<BytesMut>, BytesReadError> { 61 let tmp_bytes = self.advance_bytes(bytes_num)?; 62 let tmp_cursor = Cursor::new(tmp_bytes); 63 Ok(tmp_cursor) 64 } 65 66 pub fn read_u8(&mut self) -> Result<u8, BytesReadError> { 67 let mut cursor = self.read_bytes_cursor(1)?; 68 69 Ok(cursor.read_u8()?) 70 } 71 72 pub fn advance_u8(&mut self) -> Result<u8, BytesReadError> { 73 let mut cursor = self.advance_bytes_cursor(1)?; 74 Ok(cursor.read_u8()?) 75 } 76 77 pub fn read_u16<T: ByteOrder>(&mut self) -> Result<u16, BytesReadError> { 78 let mut cursor = self.read_bytes_cursor(2)?; 79 let val = cursor.read_u16::<T>()?; 80 Ok(val) 81 } 82 83 pub fn read_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> { 84 let mut cursor = self.read_bytes_cursor(3)?; 85 let val = cursor.read_u24::<T>()?; 86 Ok(val) 87 } 88 89 pub fn advance_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> { 90 let mut cursor = self.advance_bytes_cursor(3)?; 91 Ok(cursor.read_u24::<T>()?) 92 } 93 94 pub fn read_u32<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> { 95 let mut cursor = self.read_bytes_cursor(4)?; 96 let val = cursor.read_u32::<T>()?; 97 98 Ok(val) 99 } 100 101 pub fn read_f64<T: ByteOrder>(&mut self) -> Result<f64, BytesReadError> { 102 let mut cursor = self.read_bytes_cursor(8)?; 103 let val = cursor.read_f64::<T>()?; 104 105 Ok(val) 106 } 107 108 pub fn get(&self, index: usize) -> Result<u8, BytesReadError> { 109 if index >= self.len() { 110 return Err(BytesReadError { 111 value: BytesReadErrorValue::IndexOutofRange, 112 }); 113 } 114 115 Ok(*self.buffer.get(index).unwrap()) 116 } 117 118 pub fn len(&self) -> usize { 119 self.buffer.len() 120 } 121 122 pub fn is_empty(&self) -> bool { 123 self.len() == 0 124 } 125 126 pub fn extract_remaining_bytes(&mut self) -> BytesMut { 127 self.buffer.split_to(self.buffer.len()) 128 } 129 pub fn get_remaining_bytes(&self) -> BytesMut { 130 self.buffer.clone() 131 } 132 } 133 134 #[cfg(test)] 135 mod tests { 136 137 use super::BytesReader; 138 use bytes::BytesMut; 139 use std::cell::RefCell; 140 use std::rc::Rc; 141 142 #[test] 143 fn test_rc_refcell() { 144 let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new()))); 145 let xs: [u8; 3] = [1, 2, 3]; 146 reader.borrow_mut().extend_from_slice(&xs[..]); 147 148 let mut rv = reader.borrow_mut().read_u8().unwrap(); 149 assert_eq!(rv, 1, "Incorrect value"); 150 151 rv = reader.borrow_mut().read_u8().unwrap(); 152 assert_eq!(rv, 2, "Incorrect value"); 153 154 rv = reader.borrow_mut().read_u8().unwrap(); 155 assert_eq!(rv, 3, "Incorrect value"); 156 } 157 158 struct RefStruct { 159 pub reader: Rc<RefCell<BytesReader>>, 160 } 161 162 impl RefStruct { 163 pub fn new(reader: Rc<RefCell<BytesReader>>) -> Self { 164 Self { reader } 165 } 166 167 // pub fn read_u8(&mut self) -> u8 { 168 // return self.reader.borrow_mut().read_u8().unwrap(); 169 // } 170 171 pub fn extend_from_slice(&mut self, data: &[u8]) { 172 self.reader.borrow_mut().extend_from_slice(data); 173 } 174 } 175 176 #[test] 177 fn test_struct_rc_refcell() { 178 let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new()))); 179 180 let mut ref_struct = RefStruct::new(reader); 181 182 let xs: [u8; 3] = [1, 2, 3]; 183 ref_struct.extend_from_slice(&xs); 184 185 let mut reader = ref_struct.reader.borrow_mut(); 186 187 let mut rv = reader.read_u8().unwrap(); 188 assert_eq!(rv, 1, "Incorrect value"); 189 190 rv = reader.read_u8().unwrap(); 191 assert_eq!(rv, 2, "Incorrect value"); 192 193 rv = reader.read_u8().unwrap(); 194 assert_eq!(rv, 3, "Incorrect value"); 195 } 196 } 197