sonet_rs/buffer/
read.rs

1use std::any::Any;
2
3/// SonetReadBuf
4pub struct SonetReadBuf {
5    pub data: Vec<u8>,
6    position: i32
7}
8
9/// Default SonetReadBuf Implementation
10impl SonetReadBuf {
11    pub fn new(data: Vec<u8>) -> Self {
12        Self { data, position: 0 }
13    }
14
15    pub fn read_byte(&mut self) -> u8 {
16        let mut fixed = [0_u8; 1];
17        fixed.copy_from_slice(&[self.data[self.position as usize]]);
18        self.position += 1;
19        u8::from_be_bytes(fixed)
20    }
21
22    pub fn read_short(&mut self) -> u16 {
23        let mut fixed = [0_u8; 2];
24        fixed.copy_from_slice(&self.data[self.position as usize .. (self.position + 2) as usize]);
25        self.position += 2;
26        u16::from_be_bytes(fixed)
27    }
28
29    pub fn read_int(&mut self) -> u32 {
30        let mut fixed = [0_u8; 4];
31        fixed.copy_from_slice(&self.data[self.position as usize .. (self.position + 4) as usize]);
32        self.position += 4;
33        u32::from_be_bytes(fixed)
34    }
35
36    pub fn read_long(&mut self) -> u64 {
37        let mut fixed = [0_u8; 8];
38        fixed.copy_from_slice(&self.data[self.position as usize .. (self.position + 8) as usize]);
39        self.position += 8;
40        u64::from_be_bytes(fixed)
41    }
42
43    pub fn read_bool(&mut self) -> bool {
44        match self.read_byte() {
45            0 => false,
46            1 => true,
47            _ => panic!("Invalid Boolean")
48        }
49    }
50
51    pub fn read_byte_array(&mut self) -> Vec<u8> {
52        let size = self.read_int();
53        let mut vec = Vec::new();
54        for _ in 0..size {
55            vec.push(self.read_byte())
56        }
57        vec
58    }
59
60    pub fn read_short_array(&mut self) -> Vec<u16> {
61        let size = self.read_int();
62        let mut vec = Vec::new();
63        for _ in 0..size {
64            vec.push(self.read_short())
65        }
66        vec
67    }
68
69    pub fn read_int_array(&mut self) -> Vec<u32> {
70        let size = self.read_int();
71        let mut vec = Vec::new();
72        for _ in 0..size {
73            vec.push(self.read_int())
74        }
75        vec
76    }
77
78    pub fn read_long_array(&mut self) -> Vec<u64> {
79        let size = self.read_int();
80        let mut vec = Vec::new();
81        for _ in 0..size {
82            vec.push(self.read_long())
83        }
84        vec
85    }
86
87    pub fn read_float(&mut self) -> f32 {
88        let mut fixed = [0_u8; 4];
89        fixed.copy_from_slice(&self.data[self.position as usize .. (self.position + 4) as usize]);
90        self.position += 4;
91        f32::from_be_bytes(fixed)
92    }
93
94    pub fn read_double(&mut self) -> f64 {
95        let mut fixed = [0_u8; 8];
96        fixed.copy_from_slice(&self.data[self.position as usize .. (self.position + 8) as usize]);
97        self.position += 8;
98        f64::from_be_bytes(fixed)
99    }
100
101    pub fn read_float_array(&mut self) -> Vec<f32> {
102        let size = self.read_int();
103        let mut vec = Vec::new();
104        for _ in 0..size {
105            vec.push(self.read_float())
106        }
107        vec
108    }
109
110    pub fn read_double_array(&mut self) -> Vec<f64> {
111        let size = self.read_int();
112        let mut vec = Vec::new();
113        for _ in 0..size {
114            vec.push(self.read_double())
115        }
116        vec
117    }
118
119    pub fn read_char(&mut self) -> char {
120        char::from(self.read_byte())
121    }
122
123    pub fn read_string(&mut self) -> String {
124        let size = self.read_int();
125        let mut str = String::new();
126        for _ in 0..size {
127            str.push(self.read_char());
128        }
129        str
130    }
131
132    pub fn parse_types(&mut self, types: Vec<&'static str>) -> Vec<Box<dyn Any>> {
133        let mut vec: Vec<Box<dyn Any>> = vec![];
134        for type_name in types {
135            match type_name {
136                "String" => vec.push(Box::new(self.read_string())),
137                "char" => vec.push(Box::new(self.read_char())),
138                "u8" => vec.push(Box::new(self.read_byte())),
139                "u16" => vec.push(Box::new(self.read_short())),
140                "u32" => vec.push(Box::new(self.read_int())),
141                "u64" => vec.push(Box::new(self.read_long())),
142                "f32" => vec.push(Box::new(self.read_float())),
143                "f64" => vec.push(Box::new(self.read_double())),
144                "i8" => vec.push(Box::new(self.read_byte() as i8)),
145                "i16" => vec.push(Box::new(self.read_short() as i16)),
146                "i32" => vec.push(Box::new(self.read_int() as i32)),
147                "i64" => vec.push(Box::new(self.read_long() as i64)),
148                "Vec<u8>" => vec.push(Box::new(self.read_byte_array())),
149                "Vec<u16>" => vec.push(Box::new(self.read_short_array())),
150                "Vec<u32>" => vec.push(Box::new(self.read_int_array())),
151                "Vec<u64>" => vec.push(Box::new(self.read_long_array())),
152                "Vec<f32>" => vec.push(Box::new(self.read_float_array())),
153                "Vec<f64>" => vec.push(Box::new(self.read_double_array())),
154                "Vec<i8>" => vec.push(Box::new(self.read_byte_array().into_iter().map(|x| x as i8).collect::<Vec<i8>>())),
155                "Vec<i16>" => vec.push(Box::new(self.read_short_array().into_iter().map(|x| x as i16).collect::<Vec<i16>>())),
156                "Vec<i32>" => vec.push(Box::new(self.read_int_array().into_iter().map(|x| x as i32).collect::<Vec<i32>>())),
157                "Vec<i64>" => vec.push(Box::new(self.read_long_array().into_iter().map(|x| x as i64).collect::<Vec<i64>>())),
158                _ => panic!("Unsupported Type, {}", type_name)
159            }
160        }
161        vec
162    }
163}
sonet_rs/buffer/read.rs

sonet_rs/buffer/
read.rs
