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

bitis_lib/
lib.rs
