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    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
381    struct MsgLalaEnum {
382        e1: EnumLele,
383        b1: bool,
384        b2: bool,
385    }
386    #[rstest]
387    fn enum_msg_serde() {
388        let mut ser = Biseri::new();
389
390        let msg = MsgLalaEnum{
391            e1: EnumLele::Two,
392            b1: true,
393            b2: false,
394        };
395        msg.bit_serialize(&mut ser);
396        let r = ser.finish_add_data().unwrap();
397        let (bits, bytes) = (r.total_bits, r.total_bytes);
398        println!("bits: {}, bytes: {}", bits, bytes);
399
400        // ***
401        let mut der = Bides::from_biseri(&ser);
402
403        let mm = MsgLalaEnum::bit_deserialize(1, &mut der);
404        assert!(mm.is_some());
405        let mm = mm.unwrap();
406        println!("mm: {:?}", mm);
407
408        assert_eq!(bits, mm.1);
409        assert_eq!(msg, mm.0);
410    }
411
412}
413
414#[cfg(test)]
415mod msg_deserialization_ver {
416    use rstest::rstest;
417    use super::*;
418    pub use bitis_macros::{BiserdiMsgVersioned};
419
420    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
421    struct MsgLalaBase {
422        a1: IntWithGivenBitSize<u16, 13>,
423        b1: bool,
424        b2: bool,
425        f: f32,
426    }
427
428    // ***
429    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
430    struct MsgLalaV1 {}
431    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
432    struct MsgLalaExtV1 {
433        v1: MsgLalaV1
434    }
435    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
436    struct MsgLalaVersionedV1 {
437        base: MsgLalaBase,
438        ext: MsgLalaExtV1
439    }
440    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
441    #[allow(nonstandard_style)]
442    struct MsgLala_V2 {
443        e1: IntWithGivenBitSize<i8, 4>,
444        e2: bool,
445    }
446    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
447    #[allow(nonstandard_style)]
448    struct MsgLala_ExtV2 {
449        v1: MsgLalaV1,
450        v2: MsgLala_V2
451    }
452    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
453    struct MsgLalaVersionedV2 {
454        base: MsgLalaBase,
455        ext: MsgLala_ExtV2
456    }
457    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
458    struct MsgLalaV3 {}
459    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
460    #[allow(nonstandard_style)]
461    struct MsgLala_ExtV3 {
462        v1: MsgLalaV1,
463        v2: MsgLala_V2,
464        v3: MsgLalaV3
465    }
466    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
467    struct MsgLalaVersionedV3 {
468        base: MsgLalaBase,
469        ext: MsgLala_ExtV3
470    }
471    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
472    struct MsgLalaV4 {
473        ee1: bool,
474        ee2: bool,
475        ee3: IntWithGivenBitSize<i16, 14>,
476    }
477    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
478    struct MsgLalaExtV4 {
479        v1: MsgLalaV1,
480        v2: MsgLala_V2,
481        v3: MsgLalaV3,
482        v4: MsgLalaV4
483    }
484    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
485    struct MsgLalaVersionedV4 {
486        base: MsgLalaBase,
487        ext: MsgLalaExtV4
488    }
489    #[rstest]
490    // test backwards compability
491    fn encode_v2_decode_v1() {
492        let mut ser = Biseri::new();
493
494        let m = MsgLalaVersionedV2 {
495            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
496            ext: MsgLala_ExtV2 { v1: MsgLalaV1 {}, v2: MsgLala_V2 { e1: (-6).into(), e2: true } }
497        };
498        m.bit_serialize(&mut ser);
499        println!("m: {:?}", m);
500
501        let r = ser.finish_add_data().unwrap();
502        let (bits, bytes) = (r.total_bits, r.total_bytes);
503        println!("bits: {}, bytes: {}", bits, bytes);
504
505        // ***
506        let mut der = Bides::from_biseri(&ser.clone());
507
508        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
509        println!("v2 - mm: {:?}", mm);
510        assert!(mm.is_some());
511        let mm = mm.unwrap();
512
513        assert_eq!(bits, mm.1);
514        assert_eq!(m, mm.0);
515
516        // ***
517        let mut der = Bides::from_biseri(&ser);
518
519        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
520        println!("v1 - mm: {:?}", mm);
521        assert!(mm.is_some());
522        let mm = mm.unwrap();
523
524        assert_eq!(bits, mm.1);
525        assert_eq!(m.base, mm.0.base);
526    }
527    #[rstest]
528    fn encode_v3_decode_v2_and_v1() {
529        let mut ser = Biseri::new();
530
531        let m = MsgLalaVersionedV4 {
532            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
533            ext: MsgLalaExtV4 {
534                v1: MsgLalaV1 {},
535                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
536                v3: MsgLalaV3 {},
537                v4: MsgLalaV4 { ee1: false, ee2: true, ee3: (-5678).into(), }
538            }
539        };
540
541        m.bit_serialize(&mut ser);
542        println!("m: {:?}", m);
543
544        let r = ser.finish_add_data().unwrap();
545        let (bits, bytes) = (r.total_bits, r.total_bytes);
546        println!("bits: {}, bytes: {}", bits, bytes);
547
548        // ***
549        let mut der = Bides::from_biseri(&ser.clone());
550
551        let mm = MsgLalaVersionedV4::bit_deserialize(1, &mut der);
552        println!("v3 - mm: {:?}", mm);
553        assert!(mm.is_some());
554        let mm = mm.unwrap();
555
556        assert_eq!(bits, mm.1);
557        assert_eq!(m, mm.0);
558
559        // ***
560        let mut der = Bides::from_biseri(&ser.clone());
561
562        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
563        println!("v2 - mm: {:?}", mm);
564        assert!(mm.is_some());
565        let mm = mm.unwrap();
566
567        assert_eq!(bits, mm.1);
568        assert_eq!(m.base, mm.0.base);
569        assert_eq!(m.ext.v2, mm.0.ext.v2);
570
571        // ***
572        let mut der = Bides::from_biseri(&ser);
573
574        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
575        println!("v1 - mm: {:?}", mm);
576        assert!(mm.is_some());
577        let mm = mm.unwrap();
578
579        assert_eq!(bits, mm.1);
580        assert_eq!(m.base, mm.0.base);
581    }
582
583    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
584    enum MsgLalaVersionEnum {
585        V1(MsgLalaVersionedV1),
586        V2(MsgLalaVersionedV2),
587        V3(MsgLalaVersionedV3),
588        V4(MsgLalaVersionedV4),
589    }
590    #[rstest]
591    fn encode_v3_decode_v2_and_v4() {
592        let mut ser = Biseri::new();
593
594        let mv = MsgLalaVersionedV3 {
595            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
596            ext: MsgLala_ExtV3 {
597                v1: MsgLalaV1 {},
598                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
599                v3: MsgLalaV3 {},
600            }
601        };
602        let m = MsgLalaVersionEnum::V3(mv.clone());
603
604        m.bit_serialize(&mut ser);
605        println!("m: {:?}", m);
606
607        let r = ser.finish_add_data().unwrap();
608        let (bits, bytes) = (r.total_bits, r.total_bytes);
609        println!("bits: {}, bytes: {}", bits, bytes);
610
611        // ***
612        let mut der = Bides::from_biseri(&ser.clone());
613
614        let mm = MsgLalaVersionEnum::bit_deserialize(2, &mut der);
615        println!("v2 - mm: {:?}", mm);
616        assert!(mm.is_some());
617        let mm = mm.unwrap();
618
619        let mmm = match mm.0.clone() {
620            MsgLalaVersionEnum::V2(v) => v, _ => { panic!("Wrong enum, expected v2") }
621        };
622
623
624        assert_eq!(bits, mm.1);
625        assert_eq!(mv.base, mmm.base);
626        assert_eq!(mv.ext.v1, mmm.ext.v1);
627        assert_eq!(mv.ext.v2, mmm.ext.v2);
628
629        // ***
630        let mut der = Bides::from_biseri(&ser.clone());
631
632        let mm = MsgLalaVersionEnum::bit_deserialize(3, &mut der);
633        println!("v4 - mm: {:?}", mm);
634        assert!(mm.is_some());
635        let mm = mm.unwrap();
636
637        let mmm = match mm.0.clone() {
638            MsgLalaVersionEnum::V3(v) => v, _ => { panic!("Wrong enum, expected v3") }
639        };
640
641        assert_eq!(bits, mm.1);
642        assert_eq!(mv.base, mmm.base);
643        assert_eq!(mv.ext.v2, mmm.ext.v2);
644        assert_eq!(mv.ext.v3, mmm.ext.v3);
645    }
646}
bitis_lib/lib.rs

bitis_lib/
lib.rs
