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(&mut 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(&mut self) -> usize { 119 self.buffer.len() 120 } 121 122 pub fn extract_remaining_bytes(&mut self) -> BytesMut { 123 self.buffer.split_to(self.buffer.len()) 124 } 125 pub fn get_remaining_bytes(&mut self) -> BytesMut { 126 self.buffer.clone() 127 } 128 } 129 130 #[cfg(test)] 131 mod tests { 132 133 use super::BytesReader; 134 use bytes::BytesMut; 135 use std::cell::RefCell; 136 use std::rc::Rc; 137 138 #[test] 139 fn test_rc_refcell() { 140 let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new()))); 141 let xs: [u8; 3] = [1, 2, 3]; 142 reader.borrow_mut().extend_from_slice(&xs[..]); 143 144 let mut rv = reader.borrow_mut().read_u8().unwrap(); 145 assert_eq!(rv, 1, "Incorrect value"); 146 147 rv = reader.borrow_mut().read_u8().unwrap(); 148 assert_eq!(rv, 2, "Incorrect value"); 149 150 rv = reader.borrow_mut().read_u8().unwrap(); 151 assert_eq!(rv, 3, "Incorrect value"); 152 } 153 154 struct RefStruct { 155 pub reader: Rc<RefCell<BytesReader>>, 156 } 157 158 impl RefStruct { 159 pub fn new(reader: Rc<RefCell<BytesReader>>) -> Self { 160 Self { reader } 161 } 162 163 // pub fn read_u8(&mut self) -> u8 { 164 // return self.reader.borrow_mut().read_u8().unwrap(); 165 // } 166 167 pub fn extend_from_slice(&mut self, data: &[u8]) { 168 self.reader.borrow_mut().extend_from_slice(data); 169 } 170 } 171 172 #[test] 173 fn test_struct_rc_refcell() { 174 let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new()))); 175 176 let mut ref_struct = RefStruct::new(reader); 177 178 let xs: [u8; 3] = [1, 2, 3]; 179 ref_struct.extend_from_slice(&xs); 180 181 let mut reader = ref_struct.reader.borrow_mut(); 182 183 let mut rv = reader.read_u8().unwrap(); 184 assert_eq!(rv, 1, "Incorrect value"); 185 186 rv = reader.read_u8().unwrap(); 187 assert_eq!(rv, 2, "Incorrect value"); 188 189 rv = reader.read_u8().unwrap(); 190 assert_eq!(rv, 3, "Incorrect value"); 191 } 192 } 193