ads_proto/proto/sumup/
sumup_request.rs

1use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
2use std::io::{self, Read, Write};
3
4use crate::proto::command_id::CommandID;
5use crate::proto::proto_traits::{ReadFrom, WriteTo};
6use crate::proto::request::{ReadRequest, ReadWriteRequest, WriteRequest};
7
8///Ads Sumup Read Write Request data
9///Bundle multiple requestst toghether. Add this data to the read write request or parse from.
10#[derive(Debug, Clone, PartialEq, Eq)]
11pub struct SumupReadWriteRequest {
12    read_write_requests: Vec<ReadWriteRequest>,
13    command_id: CommandID,
14}
15
16#[derive(Debug, Clone, PartialEq)]
17struct ReadWriteAccessData {
18    index_group: u32,
19    index_offset: u32,
20    read_length: u32,
21    write_length: u32,
22}
23
24impl WriteTo for ReadWriteAccessData {
25    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
26        wtr.write_u32::<LittleEndian>(self.index_group)?;
27        wtr.write_u32::<LittleEndian>(self.index_offset)?;
28        wtr.write_u32::<LittleEndian>(self.read_length)?;
29        wtr.write_u32::<LittleEndian>(self.write_length)?;
30        Ok(())
31    }
32}
33
34impl ReadFrom for ReadWriteAccessData {
35    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
36        let index_group = read.read_u32::<LittleEndian>()?;
37        let index_offset = read.read_u32::<LittleEndian>()?;
38        let read_length = read.read_u32::<LittleEndian>()?;
39        let write_length = read.read_u32::<LittleEndian>()?;
40
41        Ok(ReadWriteAccessData {
42            index_group,
43            index_offset,
44            read_length,
45            write_length,
46        })
47    }
48}
49
50impl SumupReadWriteRequest {
51    pub fn new(read_write_requests: Vec<ReadWriteRequest>) -> Self {
52        SumupReadWriteRequest {
53            read_write_requests,
54            command_id: CommandID::ReadWrite,
55        }
56    }
57
58    pub fn expected_response_len(&self) -> u32 {
59        let mut result = 0;
60        for request in &self.read_write_requests {
61            result += request.read_length + 8; //8 byte -> 4 byte result + 4 byte length in response data
62        }
63        result
64    }
65
66    pub fn request_count(&self) -> u32 {
67        self.read_write_requests.len() as u32
68    }
69}
70
71impl WriteTo for SumupReadWriteRequest {
72    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
73        let mut access_data: Vec<u8> = Vec::new();
74        let mut data: Vec<u8> = Vec::new();
75        for request in &self.read_write_requests {
76            access_data.write_u32::<LittleEndian>(request.index_group)?;
77            access_data.write_u32::<LittleEndian>(request.index_offset)?;
78            access_data.write_u32::<LittleEndian>(request.read_length)?;
79            access_data.write_u32::<LittleEndian>(request.write_length)?;
80            data.write_all(request.data.as_slice())?;
81        }
82        access_data.append(&mut data);
83        wtr.write_all(&access_data)?;
84        Ok(())
85    }
86}
87
88impl ReadFrom for SumupReadWriteRequest {
89    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
90        let mut data_buf: Vec<u8> = Vec::new();
91        let mut read_write_access: Vec<ReadWriteAccessData> = Vec::new();
92
93        //Read all bytes and get the total length
94        read.read_to_end(&mut data_buf)?;
95        let total_data_len = data_buf.len() as u32;
96        let mut access_data_length: u32 = 0;
97        let mut data_length: u32 = 0;
98        let mut data_buf = data_buf.as_slice();
99
100        //Get the access data bytes
101        for _ in 0..total_data_len / 16 {
102            let access_data = ReadWriteAccessData::read_from(&mut data_buf)?;
103            data_length += access_data.write_length;
104            read_write_access.push(access_data);
105            access_data_length += 16;
106            if (total_data_len - data_length - access_data_length) == 0 {
107                break;
108            }
109        }
110
111        //Get the actual data/value bytes and create ReadWriteRequests
112        let mut read_write_requests: Vec<ReadWriteRequest> = Vec::new();
113        for access in read_write_access {
114            let mut buf = vec![0; access.write_length as usize];
115            data_buf.read_exact(&mut buf)?;
116            read_write_requests.push(ReadWriteRequest::new(
117                access.index_group,
118                access.index_offset,
119                access.read_length,
120                buf,
121            ));
122        }
123        Ok(SumupReadWriteRequest::new(read_write_requests))
124    }
125}
126
127///Ads Sumup Read Request data
128///Bundle multiple requestst toghether. Add this data to a read write request or parse from.
129#[derive(Debug, Clone, PartialEq, Eq)]
130pub struct SumupReadRequest {
131    read_requests: Vec<ReadRequest>,
132    command_id: CommandID,
133}
134
135impl SumupReadRequest {
136    pub fn new(read_requests: Vec<ReadRequest>) -> Self {
137        SumupReadRequest {
138            read_requests,
139            command_id: CommandID::Read,
140        }
141    }
142
143    pub fn expected_response_len(&self) -> u32 {
144        let mut result = 0;
145        for request in &self.read_requests {
146            result += request.length + 8; //8 byte -> 4 byte result + 4 byte length in response data
147        }
148        result
149    }
150
151    pub fn request_count(&self) -> u32 {
152        self.read_requests.len() as u32
153    }
154}
155
156impl WriteTo for SumupReadRequest {
157    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
158        let mut access_data: Vec<u8> = Vec::new();
159        for request in &self.read_requests {
160            request.write_to(&mut access_data)?;
161        }
162        wtr.write_all(&access_data)?;
163        Ok(())
164    }
165}
166
167impl ReadFrom for SumupReadRequest {
168    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
169        let access_data_size: usize = 12; //Index group(4 byte) + index offset(4 byte) + read length(4 byte)
170        let mut read_requests: Vec<ReadRequest> = Vec::new();
171        loop {
172            let mut buf = vec![0; access_data_size];
173            match read.read_exact(&mut buf) {
174                Ok(_) => (),
175                Err(_) => {
176                    break;
177                }
178            }
179            read_requests.push(ReadRequest::read_from(&mut buf.as_slice())?);
180        }
181        Ok(SumupReadRequest::new(read_requests))
182    }
183}
184
185///Ads Sumup Write Request data
186///Bundle multiple requestst toghether. Add this data to the read write request or parse from.
187#[derive(Debug, Clone, PartialEq, Eq)]
188pub struct SumupWriteRequest {
189    write_requests: Vec<WriteRequest>,
190    command_id: CommandID,
191}
192
193#[derive(Debug, Clone, PartialEq, Eq)]
194struct WriteAccessData {
195    index_group: u32,
196    index_offset: u32,
197    write_length: u32,
198}
199
200impl WriteTo for WriteAccessData {
201    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
202        wtr.write_u32::<LittleEndian>(self.index_group)?;
203        wtr.write_u32::<LittleEndian>(self.index_offset)?;
204        wtr.write_u32::<LittleEndian>(self.write_length)?;
205        Ok(())
206    }
207}
208
209impl ReadFrom for WriteAccessData {
210    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
211        let index_group = read.read_u32::<LittleEndian>()?;
212        let index_offset = read.read_u32::<LittleEndian>()?;
213        let write_length = read.read_u32::<LittleEndian>()?;
214
215        Ok(WriteAccessData {
216            index_group,
217            index_offset,
218            write_length,
219        })
220    }
221}
222
223impl SumupWriteRequest {
224    pub fn new(write_requests: Vec<WriteRequest>) -> Self {
225        SumupWriteRequest {
226            write_requests,
227            command_id: CommandID::Write,
228        }
229    }
230
231    pub fn request_count(&self) -> u32 {
232        self.write_requests.len() as u32
233    }
234
235    pub fn expected_response_len(&self) -> u32 {
236        self.request_count() * 4
237    }
238}
239
240impl WriteTo for SumupWriteRequest {
241    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
242        let mut access_data: Vec<u8> = Vec::new();
243        let mut data: Vec<u8> = Vec::new();
244        for request in &self.write_requests {
245            access_data.write_u32::<LittleEndian>(request.index_group)?;
246            access_data.write_u32::<LittleEndian>(request.index_offset)?;
247            access_data.write_u32::<LittleEndian>(request.length)?;
248            data.write_all(request.data.as_slice())?;
249        }
250        access_data.append(&mut data);
251        wtr.write_all(&access_data)?;
252        Ok(())
253    }
254}
255
256impl ReadFrom for SumupWriteRequest {
257    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
258        let mut data_buf: Vec<u8> = Vec::new();
259        let mut write_access: Vec<WriteAccessData> = Vec::new();
260
261        //Read all bytes and get the total length
262        read.read_to_end(&mut data_buf)?;
263        let total_data_len = data_buf.len() as u32;
264        let mut access_data_length: u32 = 0;
265        let mut data_length: u32 = 0;
266        let mut data_buf = data_buf.as_slice();
267
268        //Get the access data bytes
269        for _ in 0..total_data_len / 12 {
270            let access_data = WriteAccessData::read_from(&mut data_buf)?;
271            data_length += access_data.write_length;
272            write_access.push(access_data);
273            access_data_length += 12;
274            if (total_data_len - data_length - access_data_length) == 0 {
275                break;
276            }
277        }
278
279        //Get the actual data/value bytes and create ReadWriteRequests
280        let mut write_requests: Vec<WriteRequest> = Vec::new();
281        for access in write_access {
282            let mut buf = vec![0; access.write_length as usize];
283            data_buf.read_exact(&mut buf)?;
284            write_requests.push(WriteRequest::new(
285                access.index_group,
286                access.index_offset,
287                buf,
288            ));
289        }
290        Ok(SumupWriteRequest::new(write_requests))
291    }
292}
293
294#[cfg(test)]
295mod tests {
296    use super::*;
297
298    #[test]
299    fn sumup_read_write_request_write_to_test() {
300        let mut rw_vec: Vec<ReadWriteRequest> = Vec::new();
301        let data: u32 = 111111;
302        let data: Vec<u8> = data.to_le_bytes().to_vec();
303        let rw_1 = ReadWriteRequest::new(259, 33, 4, data);
304        rw_vec.push(rw_1);
305
306        let data: u64 = 222222;
307        let data: Vec<u8> = data.to_le_bytes().to_vec();
308        let rw_2 = ReadWriteRequest::new(260, 22, 4, data);
309        rw_vec.push(rw_2);
310
311        let mut buffer: Vec<u8> = Vec::new();
312        SumupReadWriteRequest::new(rw_vec)
313            .write_to(&mut buffer)
314            .unwrap();
315
316        let compare = vec![
317            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0,
318            8, 0, 0, 0, 7, 178, 1, 0, 14, 100, 3, 0, 0, 0, 0, 0,
319        ];
320        assert_eq!(buffer, compare);
321    }
322
323    #[test]
324    fn sumup_read_write_request_read_from_test() {
325        let read_data = vec![
326            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0,
327            8, 0, 0, 0, 7, 178, 1, 0, 14, 100, 3, 0, 0, 0, 0, 0,
328        ];
329
330        let sum_read_write_request =
331            SumupReadWriteRequest::read_from(&mut read_data.as_slice()).unwrap();
332
333        let mut rw_vec: Vec<ReadWriteRequest> = Vec::new();
334        let data: u32 = 111111;
335        let data: Vec<u8> = data.to_le_bytes().to_vec();
336        let rw_1 = ReadWriteRequest::new(259, 33, 4, data);
337        rw_vec.push(rw_1);
338
339        let data: u64 = 222222;
340        let data: Vec<u8> = data.to_le_bytes().to_vec();
341        let rw_2 = ReadWriteRequest::new(260, 22, 4, data);
342        rw_vec.push(rw_2);
343
344        let compare = SumupReadWriteRequest::new(rw_vec);
345
346        assert_eq!(
347            sum_read_write_request, compare,
348            "comparing sum_read_write_request failed"
349        );
350    }
351
352    #[test]
353    fn sumup_read_write_request_expected_response_len_test() {
354        let mut rw_vec: Vec<ReadWriteRequest> = Vec::new();
355        let data: u32 = 111111;
356        let data: Vec<u8> = data.to_le_bytes().to_vec();
357        let rw_1 = ReadWriteRequest::new(259, 33, 4, data);
358        rw_vec.push(rw_1);
359
360        let data: u64 = 222222;
361        let data: Vec<u8> = data.to_le_bytes().to_vec();
362        let rw_2 = ReadWriteRequest::new(260, 22, 4, data);
363        rw_vec.push(rw_2);
364
365        let sum_up_request = SumupReadWriteRequest::new(rw_vec);
366
367        assert_eq!(sum_up_request.expected_response_len(), 24); // 2*(4 byte read data + 8 byte) -> 4 byte result + 4 byte length in response data)
368    }
369
370    #[test]
371    fn sumup_read_write_request_request_count_test() {
372        let mut rw_vec: Vec<ReadWriteRequest> = Vec::new();
373        let data: u32 = 111111;
374        let data: Vec<u8> = data.to_le_bytes().to_vec();
375        let rw_1 = ReadWriteRequest::new(259, 33, 4, data);
376        rw_vec.push(rw_1);
377
378        let data: u64 = 222222;
379        let data: Vec<u8> = data.to_le_bytes().to_vec();
380        let rw_2 = ReadWriteRequest::new(260, 22, 4, data);
381        rw_vec.push(rw_2);
382
383        let sum_up_request = SumupReadWriteRequest::new(rw_vec);
384
385        assert_eq!(sum_up_request.request_count(), 2);
386    }
387
388    #[test]
389    fn sumup_read_request_write_to_test() {
390        let mut r_vec: Vec<ReadRequest> = Vec::new();
391        let r_1 = ReadRequest::new(259, 33, 4);
392        r_vec.push(r_1);
393
394        let r_2 = ReadRequest::new(260, 22, 4);
395        r_vec.push(r_2);
396
397        let mut buffer: Vec<u8> = Vec::new();
398        SumupReadRequest::new(r_vec).write_to(&mut buffer).unwrap();
399
400        let compare = vec![
401            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0,
402        ];
403        assert_eq!(buffer, compare);
404    }
405
406    #[test]
407    fn sumup_read_request_read_from_test() {
408        let read_data = vec![
409            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0,
410        ];
411
412        let sum_read_request = SumupReadRequest::read_from(&mut read_data.as_slice()).unwrap();
413
414        let mut r_vec: Vec<ReadRequest> = Vec::new();
415        let rw_1 = ReadRequest::new(259, 33, 4);
416        r_vec.push(rw_1);
417
418        let rw_2 = ReadRequest::new(260, 22, 4);
419        r_vec.push(rw_2);
420
421        let compare = SumupReadRequest::new(r_vec);
422
423        assert_eq!(
424            sum_read_request, compare,
425            "comparing sum_read_write_request failed"
426        );
427
428        assert_eq!(
429            sum_read_request.command_id,
430            CommandID::Read,
431            "Wrong command ID"
432        );
433
434        for request in &sum_read_request.read_requests {
435            assert_eq!(request.command_id, CommandID::Read, "wrong command id");
436            assert_eq!(request.length, 4, "Wrong length");
437        }
438        assert_eq!(
439            sum_read_request.read_requests[0].index_group, 259,
440            "Wrong index group"
441        );
442        assert_eq!(
443            sum_read_request.read_requests[0].index_offset, 33,
444            "Wrong index offset"
445        );
446        assert_eq!(
447            sum_read_request.read_requests[1].index_group, 260,
448            "Wrong index group"
449        );
450        assert_eq!(
451            sum_read_request.read_requests[1].index_offset, 22,
452            "Wrong index offset"
453        );
454    }
455
456    #[test]
457    fn sumup_write_request_write_to_test() {
458        let mut rw_vec: Vec<WriteRequest> = Vec::new();
459        let data: u32 = 111111;
460        let data: Vec<u8> = data.to_le_bytes().to_vec();
461        let rw_1 = WriteRequest::new(259, 33, data);
462        rw_vec.push(rw_1);
463
464        let data: u64 = 222222;
465        let data: Vec<u8> = data.to_le_bytes().to_vec();
466        let rw_2 = WriteRequest::new(260, 22, data);
467        rw_vec.push(rw_2);
468
469        let mut buffer: Vec<u8> = Vec::new();
470        SumupWriteRequest::new(rw_vec)
471            .write_to(&mut buffer)
472            .unwrap();
473
474        let compare = vec![
475            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 8, 0, 0, 0, 7, 178, 1, 0,
476            14, 100, 3, 0, 0, 0, 0, 0,
477        ];
478        assert_eq!(buffer, compare);
479    }
480
481    #[test]
482    fn sumup_write_request_read_from_test() {
483        let read_data = vec![
484            3, 1, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0, 22, 0, 0, 0, 8, 0, 0, 0, 7, 178, 1, 0,
485            14, 100, 3, 0, 0, 0, 0, 0,
486        ];
487
488        let sum_write_request = SumupWriteRequest::read_from(&mut read_data.as_slice()).unwrap();
489
490        let mut rw_vec: Vec<WriteRequest> = Vec::new();
491        let data: u32 = 111111;
492        let data: Vec<u8> = data.to_le_bytes().to_vec();
493        let rw_1 = WriteRequest::new(259, 33, data);
494        rw_vec.push(rw_1);
495
496        let data: u64 = 222222;
497        let data: Vec<u8> = data.to_le_bytes().to_vec();
498        let rw_2 = WriteRequest::new(260, 22, data);
499        rw_vec.push(rw_2);
500
501        let compare = SumupWriteRequest::new(rw_vec);
502
503        assert_eq!(
504            sum_write_request, compare,
505            "comparing sum_read_write_request failed"
506        );
507    }
508}
ads_proto/proto/sumup/sumup_request.rs

ads_proto/proto/sumup/
sumup_request.rs
