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