bitis_lib/
lib.rs

1// #![feature(trace_macros)]
2//
3// trace_macros!(true);
4//
5
6pub mod msg_test;
7pub mod lib_impl;
8
9pub use lib_impl::berde::*;
10pub use lib_impl::compiler::*;
11pub use bitis_macros::{BiserdiMsg, BiserdiOneOf, BiserdiEnum};
12pub use std::result;
13
14
15pub fn serialize<T: BiserdiTrait>(data: &T) -> Vec<u8>{
16    let mut ser = Biseri::new();
17
18    data.bit_serialize(&mut ser);
19    ser.finish_add_data().unwrap();
20    // println!("bits: {}, bytes: {}", _bits, _bytes);
21
22    ser.get_data().to_owned()
23}
24pub fn deserialize<T: BiserdiTrait>(data: &Vec<u8>) -> Option<(T, u64)> {
25    let mut der = Bides::from_vec(data);
26
27    T::bit_deserialize(1, &mut der)
28}
29
30
31
32#[derive(Debug)]
33pub enum MessageManagerError {
34    InvalidMessage,
35}
36pub trait MessageWithHeaderTrait : Default {
37    fn serialize_header(&mut self, payload_size: usize, biseri: &mut Biseri) -> Option<u64>;
38    fn serialize_payload(&self, biseri: &mut Biseri) -> Option<u64>;
39    fn deserialize_header(&mut self, data: &mut Bides) -> Result<Option<(usize, usize)>, MessageManagerError>;
40    fn deserialize_payload(&mut self, data: &mut Bides) -> Option<usize>;
41}
42#[derive(Debug, Clone)]
43pub struct MessageManager<MWH> {
44    pub bides: Bides,
45    pub data_unused: Vec<u8>,
46    pub header_successfully_read: bool,
47
48    pub payload_size: usize,
49    pub msg_with_header: MWH,
50}
51#[allow(unused)]
52impl<MWH: MessageWithHeaderTrait + Default> MessageManager<MWH> {
53    fn create() -> Self {
54        Self{bides: Bides::new(), data_unused: Vec::new(), header_successfully_read: false,
55            payload_size: 0, msg_with_header: Default::default(), }
56    }
57
58    fn bit_serialize(&mut self) -> Vec<u8> {
59        let mut biseri_payload =  Biseri::new();
60        self.msg_with_header.serialize_payload(&mut biseri_payload);
61        let rp = biseri_payload.finish_add_data().unwrap();
62        self.payload_size = rp.total_bytes as usize;
63        
64        let mut biseri_header =  Biseri::new();
65        self.msg_with_header.serialize_header(rp.total_bytes as usize, &mut biseri_header);
66        biseri_header.finish_add_data().unwrap();
67        
68        let mut data = biseri_header.get_data();
69        data.extend(biseri_payload.get_data());
70
71        data
72    }
73
74    fn append_data_and_try_deserialize(&mut self, data: &Vec<u8>) -> Result<Option<usize>, MessageManagerError> {
75        self.bides.append_data(data);
76
77        if !self.header_successfully_read {
78            if self.bides.data_cache.len() == 0 { return Ok(None); }
79
80            let (p, b) = match self.msg_with_header.deserialize_header(&mut self.bides)? {
81                None => { return Ok(None); } Some(v) => { v }
82            };
83            self.payload_size = p;
84            self.header_successfully_read = true;
85            self.bides.data_cache.drain(..b);
86            self.bides.reset_position();
87        }
88        if self.header_successfully_read {
89            if self.bides.data_cache.len() < self.payload_size { return Ok(None); }
90            if self.bides.data_cache.len() > self.payload_size {
91                self.data_unused.extend(self.bides.data_cache[self.payload_size..].to_vec());
92                self.bides.data_cache.truncate(self.payload_size);
93            }
94
95            match self.msg_with_header.deserialize_payload(&mut self.bides) {
96                Some(s) => Ok(Some(s)), None => Ok(None)
97            }
98        }
99        else { Ok(None) }
100    }
101}
102
103
104#[cfg(test)]
105mod msg_manager_test {
106    use rstest::rstest;
107    use super::*;
108
109    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
110    struct MsgHeaderByteTwo {
111        size_high: VarWithGivenBitSize<u8, 6>,
112        must_be_one: VarWithGivenBitSize<u8, 2>,
113    }
114    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
115    struct MsgHeader {
116        size_low: VarWithGivenBitSize<u8, 6>,
117        must_be_one: VarWithGivenBitSize<u8, 1>,
118        byte_two: Option<MsgHeaderByteTwo>
119    }
120    #[derive(BiserdiMsg, Debug, Clone, PartialEq, Default)]
121    struct MsgLalaBase {
122        a1: VarWithGivenBitSize<u16, 13>,
123        b1: bool,
124        b2: bool,
125        f: f32,
126    }
127
128    #[derive(Debug, Clone, PartialEq, Default)]
129    struct MsgWH{
130        header: MsgHeader,
131        payload: MsgLalaBase,
132    }
133    impl MessageWithHeaderTrait for MsgWH {
134        fn serialize_header(&mut self, payload_size: usize, biseri: &mut Biseri) -> Option<u64> {
135            let payload_size_high = (payload_size>>6) as u8;
136            self.header = MsgHeader{
137                size_low: ((payload_size & ((1<<6)-1)) as u8).into(),
138                must_be_one: 1.into(),
139                byte_two: if payload_size_high > 0 {
140                    Some(MsgHeaderByteTwo{size_high: payload_size_high.into(), must_be_one: 1.into() }) }
141                else { None }
142            };
143            self.header.bit_serialize(biseri)
144        }
145
146        fn serialize_payload(&self, biseri: &mut Biseri) -> Option<u64> {
147            self.payload.bit_serialize(biseri)
148        }
149
150        fn deserialize_header(&mut self, bides: &mut Bides) -> Result<Option<(usize, usize)>, MessageManagerError> {
151            let bit_size = match MsgHeader::bit_deserialize(0, bides) {
152                None => {
153                    bides.reset_position();
154                    return Ok(None)
155                }
156                Some((h, r)) => {
157                    self.header = h;
158                    r
159                }
160            };
161            if self.header.must_be_one.val != 1 { return Err(MessageManagerError::InvalidMessage) }
162            if let Some(v) = self.header.byte_two.clone() {
163                if v.must_be_one.val != 1 { return Err(MessageManagerError::InvalidMessage) }
164            }
165            Ok(Some(
166                (
167                    (self.header.size_low.val as usize) +
168                        if let Some(bt) = self.header.byte_two.clone()
169                        { (bt.size_high.val as usize) << 6 } else { 0 },
170                    (bit_size >> 3) as usize
171                )
172            ))
173        }
174
175        fn deserialize_payload(&mut self, bides: &mut Bides) -> Option<usize> {
176            match MsgLalaBase::bit_deserialize(0, bides) {
177                None => { bides.reset_position(); None }
178                Some((p, s)) => {
179                    self.payload = p;
180                    Some(s as usize)
181                }
182            }
183        }
184    }
185    #[test]
186    fn msg_manager_simple() {
187        let payload = MsgLalaBase{ a1: 1234.into(), b1: false, b2: true, f: 12.34 };
188        let mut s1 = Biseri::new();
189        payload.bit_serialize(&mut s1);
190        s1.finish_add_data().unwrap();
191        let s = s1.get_data().len();
192
193        let header = MsgHeader{
194            size_low: ((s & ((1<<6)-1)) as u8).into(),
195            must_be_one: 1.into(),
196            byte_two: if (s>>6) > 0 {
197                Some(MsgHeaderByteTwo{size_high: ((s>>6) as u8).into(), must_be_one: 1.into() }) }
198            else { None }
199        };
200        let mut s2 = Biseri::new();
201        header.bit_serialize(&mut s2);
202        s2.finish_add_data().unwrap();
203        let mut data = s2.get_data();
204        data.extend(s1.get_data());
205
206        let mut mm = MessageManager::<MsgWH>::create();
207        let r = mm.append_data_and_try_deserialize(&vec![data[0]]);
208        assert!(r.is_ok());
209        let r = r.unwrap();
210        assert!(r.is_none());
211
212        let r = mm.append_data_and_try_deserialize(&data[1..].to_vec());
213        assert!(r.is_ok());
214        let r = r.unwrap();
215        assert!(r.is_some());
216
217        println!("{:#?}", mm);
218        assert_eq!(mm.msg_with_header.header, header);
219        assert_eq!(mm.msg_with_header.payload, payload);
220    }
221    #[test]
222    fn msg_manager_full() {
223        let mut mm_ser = MessageManager::<MsgWH>::create();
224
225        mm_ser.msg_with_header.payload = MsgLalaBase{ a1: 1234.into(), b1: false, b2: true, f: 12.34 };
226        let data = mm_ser.bit_serialize();
227        println!("{:#?}", mm_ser);
228        println!("data len: {}", data.len());
229        
230        let mut mm_des = MessageManager::<MsgWH>::create();
231        let r = mm_des.append_data_and_try_deserialize(&vec![data[0]]);
232        assert!(r.is_ok());
233        let r = r.unwrap();
234        assert!(r.is_none());
235
236        let r = mm_des.append_data_and_try_deserialize(&data[1..].to_vec());
237        assert!(r.is_ok());
238        let r = r.unwrap();
239        assert!(r.is_some());
240
241        println!("{:#?}", mm_des);
242        assert_eq!(mm_des.msg_with_header.header, mm_ser.msg_with_header.header);
243        assert_eq!(mm_des.msg_with_header.payload, mm_ser.msg_with_header.payload);
244    }
245}
246
247#[cfg(test)]
248mod msg_deserialization {
249    use rstest::rstest;
250    use super::*;
251
252    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
253    struct MsgLalaBase {
254        a1: VarWithGivenBitSize<u16, 13>,
255        b1: bool,
256        b2: bool,
257        f: f32,
258    }
259
260    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
261    struct MsgLili {
262        inner_msg: MsgLalaBase,
263        b1: bool,
264        b2: VarWithGivenBitSize<u8, 7>,
265        signed: VarWithGivenBitSize<i8, 4>,
266    }
267
268    #[rstest]
269    fn msg_simple_msg_serde() {
270        let mut ser = Biseri::new();
271
272        let m = MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 };
273        println!("m: {:?}", m);
274
275        m.bit_serialize(&mut ser);
276        let r = ser.finish_add_data().unwrap();
277        let (bits, bytes) = (r.total_bits, r.total_bytes);
278        println!("bits: {}, bytes: {}", bits, bytes);
279
280        // ***
281        let mut der = Bides::from_biseri(&ser);
282
283        let mm = MsgLalaBase::bit_deserialize(1, &mut der);
284        assert!(mm.is_some());
285        let mm = mm.unwrap();
286        println!("mm: {:?}", mm);
287
288        assert_eq!(m, mm.0);
289    }
290
291    #[rstest]
292    fn msg_with_inner_msg_serde() {
293        let mut ser = Biseri::new();
294
295        let m = MsgLili {
296            inner_msg: MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 },
297            b1: true,
298            b2: 11.into(),
299            signed: (-3).into()
300        };
301        println!("m: {:?}", m);
302
303        m.bit_serialize(&mut ser);
304        let r = ser.finish_add_data().unwrap();
305        let (bits, bytes) = (r.total_bits, r.total_bytes);
306        println!("bits: {}, bytes: {}", bits, bytes);
307
308        // ***
309        let mut der = Bides::from_biseri(&ser);
310
311        let mm = MsgLili::bit_deserialize(1, &mut der);
312        assert!(mm.is_some());
313        let mm = mm.unwrap();
314        println!("mm: {:?}", mm);
315
316        assert_eq!(m, mm.0);
317    }
318
319    #[derive(BiserdiOneOf, Debug, Clone, PartialEq)]
320    #[biserdi_enum_id_dynbits(4)]
321    enum OOLili {
322        InnerMsg(MsgLalaBase),
323        B1(bool),
324        F2(f32),
325        //#[biserdi_enum_id_bits(22)]
326        Signed(VarWithGivenBitSize<i8, 6>),
327    }
328
329    fn oneof_test_serde(m: OOLili) {
330        println!("m: {:?}", m);
331
332        let mut ser = Biseri::new();
333
334        m.bit_serialize(&mut ser);
335        let r = ser.finish_add_data().unwrap();
336        let (bits, bytes) = (r.total_bits, r.total_bytes);
337        println!("bits: {}, bytes: {}", bits, bytes);
338
339        // ***
340        let mut der = Bides::from_biseri(&ser);
341
342        let mm = OOLili::bit_deserialize(1, &mut der);
343        assert!(mm.is_some());
344        let mm = mm.unwrap();
345        println!("mm: {:?}", mm);
346
347        assert_eq!(bits, mm.1);
348        assert_eq!(m, mm.0);
349    }
350    #[rstest]
351    fn oneof_msg_serde() {
352        let m = OOLili::InnerMsg(MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 });
353        oneof_test_serde(m);
354    }
355    #[rstest]
356    fn oneof_bool_serde() {
357        let m = OOLili::B1(true);
358        oneof_test_serde(m);
359    }
360    #[rstest]
361    fn oneof_f32_serde() {
362        let m = OOLili::F2(98765.54321);
363        oneof_test_serde(m);
364    }
365    #[rstest]
366    fn oneof_var_with_given_bit_size_serde() {
367        let m = OOLili::Signed((-3).into());
368        oneof_test_serde(m);
369    }
370
371    #[derive(BiserdiEnum, Debug, Clone, PartialEq)]
372    #[biserdi_enum_id_dynbits(4)]
373    #[allow(nonstandard_style)]
374    enum EnumLele {
375        One,
376        Two,
377        Three
378    }
379    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
380    struct MsgLalaEnum {
381        e1: EnumLele,
382        b1: bool,
383        b2: bool,
384    }
385    #[rstest]
386    fn enum_msg_serde() {
387        let mut ser = Biseri::new();
388
389        let msg = MsgLalaEnum{
390            e1: EnumLele::Two,
391            b1: true,
392            b2: false,
393        };
394        msg.bit_serialize(&mut ser);
395        let r = ser.finish_add_data().unwrap();
396        let (bits, bytes) = (r.total_bits, r.total_bytes);
397        println!("bits: {}, bytes: {}", bits, bytes);
398
399        // ***
400        let mut der = Bides::from_biseri(&ser);
401
402        let mm = MsgLalaEnum::bit_deserialize(1, &mut der);
403        assert!(mm.is_some());
404        let mm = mm.unwrap();
405        println!("mm: {:?}", mm);
406
407        assert_eq!(bits, mm.1);
408        assert_eq!(msg, mm.0);
409    }
410
411}
412
413#[cfg(test)]
414mod msg_deserialization_ver {
415    use rstest::rstest;
416    use super::*;
417    pub use bitis_macros::{BiserdiMsgVersioned};
418
419    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
420    struct MsgLalaBase {
421        a1: VarWithGivenBitSize<u16, 13>,
422        b1: bool,
423        b2: bool,
424        f: f32,
425    }
426
427    // ***
428    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
429    struct MsgLalaV1 {}
430    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
431    struct MsgLalaExtV1 {
432        v1: MsgLalaV1
433    }
434    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
435    struct MsgLalaVersionedV1 {
436        base: MsgLalaBase,
437        ext: MsgLalaExtV1
438    }
439    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
440    #[allow(nonstandard_style)]
441    struct MsgLala_V2 {
442        e1: VarWithGivenBitSize<i8, 4>,
443        e2: bool,
444    }
445    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
446    #[allow(nonstandard_style)]
447    struct MsgLala_ExtV2 {
448        v1: MsgLalaV1,
449        v2: MsgLala_V2
450    }
451    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
452    struct MsgLalaVersionedV2 {
453        base: MsgLalaBase,
454        ext: MsgLala_ExtV2
455    }
456    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
457    struct MsgLalaV3 {}
458    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
459    #[allow(nonstandard_style)]
460    struct MsgLala_ExtV3 {
461        v1: MsgLalaV1,
462        v2: MsgLala_V2,
463        v3: MsgLalaV3
464    }
465    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
466    struct MsgLalaVersionedV3 {
467        base: MsgLalaBase,
468        ext: MsgLala_ExtV3
469    }
470    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
471    struct MsgLalaV4 {
472        ee1: bool,
473        ee2: bool,
474        ee3: VarWithGivenBitSize<i16, 14>,
475    }
476    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
477    struct MsgLalaExtV4 {
478        v1: MsgLalaV1,
479        v2: MsgLala_V2,
480        v3: MsgLalaV3,
481        v4: MsgLalaV4
482    }
483    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
484    struct MsgLalaVersionedV4 {
485        base: MsgLalaBase,
486        ext: MsgLalaExtV4
487    }
488    #[rstest]
489    // test backwards compability
490    fn encode_v2_decode_v1() {
491        let mut ser = Biseri::new();
492
493        let m = MsgLalaVersionedV2 {
494            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
495            ext: MsgLala_ExtV2 { v1: MsgLalaV1 {}, v2: MsgLala_V2 { e1: (-6).into(), e2: true } }
496        };
497        m.bit_serialize(&mut ser);
498        println!("m: {:?}", m);
499
500        let r = ser.finish_add_data().unwrap();
501        let (bits, bytes) = (r.total_bits, r.total_bytes);
502        println!("bits: {}, bytes: {}", bits, bytes);
503
504        // ***
505        let mut der = Bides::from_biseri(&ser.clone());
506
507        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
508        println!("v2 - mm: {:?}", mm);
509        assert!(mm.is_some());
510        let mm = mm.unwrap();
511
512        assert_eq!(bits, mm.1);
513        assert_eq!(m, mm.0);
514
515        // ***
516        let mut der = Bides::from_biseri(&ser);
517
518        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
519        println!("v1 - mm: {:?}", mm);
520        assert!(mm.is_some());
521        let mm = mm.unwrap();
522
523        assert_eq!(bits, mm.1);
524        assert_eq!(m.base, mm.0.base);
525    }
526    #[rstest]
527    fn encode_v3_decode_v2_and_v1() {
528        let mut ser = Biseri::new();
529
530        let m = MsgLalaVersionedV4 {
531            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
532            ext: MsgLalaExtV4 {
533                v1: MsgLalaV1 {},
534                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
535                v3: MsgLalaV3 {},
536                v4: MsgLalaV4 { ee1: false, ee2: true, ee3: (-5678).into(), }
537            }
538        };
539
540        m.bit_serialize(&mut ser);
541        println!("m: {:?}", m);
542
543        let r = ser.finish_add_data().unwrap();
544        let (bits, bytes) = (r.total_bits, r.total_bytes);
545        println!("bits: {}, bytes: {}", bits, bytes);
546
547        // ***
548        let mut der = Bides::from_biseri(&ser.clone());
549
550        let mm = MsgLalaVersionedV4::bit_deserialize(1, &mut der);
551        println!("v3 - mm: {:?}", mm);
552        assert!(mm.is_some());
553        let mm = mm.unwrap();
554
555        assert_eq!(bits, mm.1);
556        assert_eq!(m, mm.0);
557
558        // ***
559        let mut der = Bides::from_biseri(&ser.clone());
560
561        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
562        println!("v2 - mm: {:?}", mm);
563        assert!(mm.is_some());
564        let mm = mm.unwrap();
565
566        assert_eq!(bits, mm.1);
567        assert_eq!(m.base, mm.0.base);
568        assert_eq!(m.ext.v2, mm.0.ext.v2);
569
570        // ***
571        let mut der = Bides::from_biseri(&ser);
572
573        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
574        println!("v1 - mm: {:?}", mm);
575        assert!(mm.is_some());
576        let mm = mm.unwrap();
577
578        assert_eq!(bits, mm.1);
579        assert_eq!(m.base, mm.0.base);
580    }
581
582    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
583    enum MsgLalaVersionEnum {
584        V1(MsgLalaVersionedV1),
585        V2(MsgLalaVersionedV2),
586        V3(MsgLalaVersionedV3),
587        V4(MsgLalaVersionedV4),
588    }
589    #[rstest]
590    fn encode_v3_decode_v2_and_v4() {
591        let mut ser = Biseri::new();
592
593        let mv = MsgLalaVersionedV3 {
594            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
595            ext: MsgLala_ExtV3 {
596                v1: MsgLalaV1 {},
597                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
598                v3: MsgLalaV3 {},
599            }
600        };
601        let m = MsgLalaVersionEnum::V3(mv.clone());
602
603        m.bit_serialize(&mut ser);
604        println!("m: {:?}", m);
605
606        let r = ser.finish_add_data().unwrap();
607        let (bits, bytes) = (r.total_bits, r.total_bytes);
608        println!("bits: {}, bytes: {}", bits, bytes);
609
610        // ***
611        let mut der = Bides::from_biseri(&ser.clone());
612
613        let mm = MsgLalaVersionEnum::bit_deserialize(2, &mut der);
614        println!("v2 - mm: {:?}", mm);
615        assert!(mm.is_some());
616        let mm = mm.unwrap();
617
618        let mmm = match mm.0.clone() {
619            MsgLalaVersionEnum::V2(v) => v, _ => { panic!("Wrong enum, expected v2") }
620        };
621
622
623        assert_eq!(bits, mm.1);
624        assert_eq!(mv.base, mmm.base);
625        assert_eq!(mv.ext.v1, mmm.ext.v1);
626        assert_eq!(mv.ext.v2, mmm.ext.v2);
627
628        // ***
629        let mut der = Bides::from_biseri(&ser.clone());
630
631        let mm = MsgLalaVersionEnum::bit_deserialize(3, &mut der);
632        println!("v4 - mm: {:?}", mm);
633        assert!(mm.is_some());
634        let mm = mm.unwrap();
635
636        let mmm = match mm.0.clone() {
637            MsgLalaVersionEnum::V3(v) => v, _ => { panic!("Wrong enum, expected v3") }
638        };
639
640        assert_eq!(bits, mm.1);
641        assert_eq!(mv.base, mmm.base);
642        assert_eq!(mv.ext.v2, mmm.ext.v2);
643        assert_eq!(mv.ext.v3, mmm.ext.v3);
644    }
645}
bitis_lib/lib.rs

bitis_lib/
lib.rs
