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};
12
13pub fn serialize<T: BiserdiTrait>(data: &T) -> Vec<u8>{
14    let mut ser = Biseri::new();
15
16    data.bit_serialize(&mut ser);
17    let (_bits, _bytes) = ser.finish_add_data().unwrap();
18    // println!("bits: {}, bytes: {}", _bits, _bytes);
19
20    ser.get_data().to_owned()
21}
22pub fn deserialize<T: BiserdiTrait>(data: &Vec<u8>) -> Option<(T, u64)> {
23    let mut der = Bides::from_vec(data);
24
25    T::bit_deserialize(1, &mut der)
26}
27
28#[cfg(test)]
29mod msg_deserialization {
30    use rstest::rstest;
31    use super::*;
32
33
34    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
35    struct MsgLalaBase {
36        a1: VarWithGivenBitSize<u16, 13>,
37        b1: bool,
38        b2: bool,
39        f: f32,
40    }
41
42    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
43    struct MsgLili {
44        inner_msg: MsgLalaBase,
45        b1: bool,
46        b2: VarWithGivenBitSize<u8, 7>,
47        signed: VarWithGivenBitSize<i8, 4>,
48    }
49
50    #[rstest]
51    fn msg_simple_msg_serde() {
52        let mut ser = Biseri::new();
53
54        let m = MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 };
55        println!("m: {:?}", m);
56
57        m.bit_serialize(&mut ser);
58        let (bits, bytes) = ser.finish_add_data().unwrap();
59        println!("bits: {}, bytes: {}", bits, bytes);
60
61        // ***
62        let mut der = Bides::from_biseri(&ser);
63
64        let mm = MsgLalaBase::bit_deserialize(1, &mut der);
65        assert!(mm.is_some());
66        let mm = mm.unwrap();
67        println!("mm: {:?}", mm);
68
69        assert_eq!(m, mm.0);
70    }
71
72    #[rstest]
73    fn msg_with_inner_msg_serde() {
74        let mut ser = Biseri::new();
75
76        let m = MsgLili {
77            inner_msg: MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 },
78            b1: true,
79            b2: 11.into(),
80            signed: (-3).into()
81        };
82        println!("m: {:?}", m);
83
84        m.bit_serialize(&mut ser);
85        let (bits, bytes) = ser.finish_add_data().unwrap();
86        println!("bits: {}, bytes: {}", bits, bytes);
87
88        // ***
89        let mut der = Bides::from_biseri(&ser);
90
91        let mm = MsgLili::bit_deserialize(1, &mut der);
92        assert!(mm.is_some());
93        let mm = mm.unwrap();
94        println!("mm: {:?}", mm);
95
96        assert_eq!(m, mm.0);
97    }
98
99    #[derive(BiserdiOneOf, Debug, Clone, PartialEq)]
100    #[biserdi_enum_id_dynbits(4)]
101    enum OOLili {
102        InnerMsg(MsgLalaBase),
103        B1(bool),
104        F2(f32),
105        //#[biserdi_enum_id_bits(22)]
106        Signed(VarWithGivenBitSize<i8, 6>),
107    }
108
109    fn oneof_test_serde(m: OOLili) {
110        println!("m: {:?}", m);
111
112        let mut ser = Biseri::new();
113
114        m.bit_serialize(&mut ser);
115        let (bits, bytes) = ser.finish_add_data().unwrap();
116        println!("bits: {}, bytes: {}", bits, bytes);
117
118        // ***
119        let mut der = Bides::from_biseri(&ser);
120
121        let mm = OOLili::bit_deserialize(1, &mut der);
122        assert!(mm.is_some());
123        let mm = mm.unwrap();
124        println!("mm: {:?}", mm);
125
126        assert_eq!(bits, mm.1);
127        assert_eq!(m, mm.0);
128    }
129    #[rstest]
130    fn oneof_msg_serde() {
131        let m = OOLili::InnerMsg(MsgLalaBase { a1: 7345.into(), b1: true, b2: false, f: 12345.6789 });
132        oneof_test_serde(m);
133    }
134    #[rstest]
135    fn oneof_bool_serde() {
136        let m = OOLili::B1(true);
137        oneof_test_serde(m);
138    }
139    #[rstest]
140    fn oneof_f32_serde() {
141        let m = OOLili::F2(98765.54321);
142        oneof_test_serde(m);
143    }
144    #[rstest]
145    fn oneof_var_with_given_bit_size_serde() {
146        let m = OOLili::Signed((-3).into());
147        oneof_test_serde(m);
148    }
149
150    #[derive(BiserdiEnum, Debug, Clone, PartialEq)]
151    #[biserdi_enum_id_dynbits(4)]
152    #[allow(nonstandard_style)]
153    enum EnumLele {
154        One,
155        Two,
156        Three
157    }
158    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
159    struct MsgLalaEnum {
160        e1: EnumLele,
161        b1: bool,
162        b2: bool,
163    }
164    #[rstest]
165    fn enum_msg_serde() {
166        let mut ser = Biseri::new();
167
168        let msg = MsgLalaEnum{
169            e1: EnumLele::Two,
170            b1: true,
171            b2: false,
172        };
173        msg.bit_serialize(&mut ser);
174        let (bits, bytes) = ser.finish_add_data().unwrap();
175        println!("bits: {}, bytes: {}", bits, bytes);
176
177        // ***
178        let mut der = Bides::from_biseri(&ser);
179
180        let mm = MsgLalaEnum::bit_deserialize(1, &mut der);
181        assert!(mm.is_some());
182        let mm = mm.unwrap();
183        println!("mm: {:?}", mm);
184
185        assert_eq!(bits, mm.1);
186        assert_eq!(msg, mm.0);
187    }
188
189}
190
191#[cfg(test)]
192mod msg_deserialization_ver {
193    use rstest::rstest;
194    use super::*;
195    pub use bitis_macros::{BiserdiMsgVersioned};
196
197    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
198    struct MsgLalaBase {
199        a1: VarWithGivenBitSize<u16, 13>,
200        b1: bool,
201        b2: bool,
202        f: f32,
203    }
204
205    // ***
206    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
207    struct MsgLalaV1 {}
208    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
209    struct MsgLalaExtV1 {
210        v1: MsgLalaV1
211    }
212    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
213    struct MsgLalaVersionedV1 {
214        base: MsgLalaBase,
215        ext: MsgLalaExtV1
216    }
217    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
218    #[allow(nonstandard_style)]
219    struct MsgLala_V2 {
220        e1: VarWithGivenBitSize<i8, 4>,
221        e2: bool,
222    }
223    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
224    #[allow(nonstandard_style)]
225    struct MsgLala_ExtV2 {
226        v1: MsgLalaV1,
227        v2: MsgLala_V2
228    }
229    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
230    struct MsgLalaVersionedV2 {
231        base: MsgLalaBase,
232        ext: MsgLala_ExtV2
233    }
234    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
235    struct MsgLalaV3 {}
236    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
237    #[allow(nonstandard_style)]
238    struct MsgLala_ExtV3 {
239        v1: MsgLalaV1,
240        v2: MsgLala_V2,
241        v3: MsgLalaV3
242    }
243    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
244    struct MsgLalaVersionedV3 {
245        base: MsgLalaBase,
246        ext: MsgLala_ExtV3
247    }
248    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
249    struct MsgLalaV4 {
250        ee1: bool,
251        ee2: bool,
252        ee3: VarWithGivenBitSize<i16, 14>,
253    }
254    #[derive(BiserdiMsg, Debug, Clone, PartialEq)]
255    struct MsgLalaExtV4 {
256        v1: MsgLalaV1,
257        v2: MsgLala_V2,
258        v3: MsgLalaV3,
259        v4: MsgLalaV4
260    }
261    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
262    struct MsgLalaVersionedV4 {
263        base: MsgLalaBase,
264        ext: MsgLalaExtV4
265    }
266    #[rstest]
267    // test backwards compability
268    fn encode_v2_decode_v1() {
269        let mut ser = Biseri::new();
270
271        let m = MsgLalaVersionedV2 {
272            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
273            ext: MsgLala_ExtV2 { v1: MsgLalaV1 {}, v2: MsgLala_V2 { e1: (-6).into(), e2: true } }
274        };
275        m.bit_serialize(&mut ser);
276        println!("m: {:?}", m);
277
278        let (bits, bytes) = ser.finish_add_data().unwrap();
279        println!("bits: {}, bytes: {}", bits, bytes);
280
281        // ***
282        let mut der = Bides::from_biseri(&ser.clone());
283
284        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
285        println!("v2 - mm: {:?}", mm);
286        assert!(mm.is_some());
287        let mm = mm.unwrap();
288
289        assert_eq!(bits, mm.1);
290        assert_eq!(m, mm.0);
291
292        // ***
293        let mut der = Bides::from_biseri(&ser);
294
295        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
296        println!("v1 - mm: {:?}", mm);
297        assert!(mm.is_some());
298        let mm = mm.unwrap();
299
300        assert_eq!(bits, mm.1);
301        assert_eq!(m.base, mm.0.base);
302    }
303    #[rstest]
304    fn encode_v3_decode_v2_and_v1() {
305        let mut ser = Biseri::new();
306
307        let m = MsgLalaVersionedV4 {
308            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
309            ext: MsgLalaExtV4 {
310                v1: MsgLalaV1 {},
311                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
312                v3: MsgLalaV3 {},
313                v4: MsgLalaV4 { ee1: false, ee2: true, ee3: (-5678).into(), }
314            }
315        };
316
317        m.bit_serialize(&mut ser);
318        println!("m: {:?}", m);
319
320        let (bits, bytes) = ser.finish_add_data().unwrap();
321        println!("bits: {}, bytes: {}", bits, bytes);
322
323        // ***
324        let mut der = Bides::from_biseri(&ser.clone());
325
326        let mm = MsgLalaVersionedV4::bit_deserialize(1, &mut der);
327        println!("v3 - mm: {:?}", mm);
328        assert!(mm.is_some());
329        let mm = mm.unwrap();
330
331        assert_eq!(bits, mm.1);
332        assert_eq!(m, mm.0);
333
334        // ***
335        let mut der = Bides::from_biseri(&ser.clone());
336
337        let mm = MsgLalaVersionedV2::bit_deserialize(1, &mut der);
338        println!("v2 - mm: {:?}", mm);
339        assert!(mm.is_some());
340        let mm = mm.unwrap();
341
342        assert_eq!(bits, mm.1);
343        assert_eq!(m.base, mm.0.base);
344        assert_eq!(m.ext.v2, mm.0.ext.v2);
345
346        // ***
347        let mut der = Bides::from_biseri(&ser);
348
349        let mm = MsgLalaVersionedV1::bit_deserialize(1, &mut der);
350        println!("v1 - mm: {:?}", mm);
351        assert!(mm.is_some());
352        let mm = mm.unwrap();
353
354        assert_eq!(bits, mm.1);
355        assert_eq!(m.base, mm.0.base);
356    }
357
358    #[derive(BiserdiMsgVersioned, Debug, Clone, PartialEq)]
359    enum MsgLalaVersionEnum {
360        V1(MsgLalaVersionedV1),
361        V2(MsgLalaVersionedV2),
362        V3(MsgLalaVersionedV3),
363        V4(MsgLalaVersionedV4),
364    }
365    #[rstest]
366    fn encode_v3_decode_v2_and_v4() {
367        let mut ser = Biseri::new();
368
369        let mv = MsgLalaVersionedV3 {
370            base: MsgLalaBase { a1: 1234.into(), b1: true, b2: false, f: 9876.54321, },
371            ext: MsgLala_ExtV3 {
372                v1: MsgLalaV1 {},
373                v2: MsgLala_V2 { e1: (-6).into(), e2: true },
374                v3: MsgLalaV3 {},
375            }
376        };
377        let m = MsgLalaVersionEnum::V3(mv.clone());
378
379        m.bit_serialize(&mut ser);
380        println!("m: {:?}", m);
381
382        let (bits, bytes) = ser.finish_add_data().unwrap();
383        println!("bits: {}, bytes: {}", bits, bytes);
384
385        // ***
386        let mut der = Bides::from_biseri(&ser.clone());
387
388        let mm = MsgLalaVersionEnum::bit_deserialize(2, &mut der);
389        println!("v2 - mm: {:?}", mm);
390        assert!(mm.is_some());
391        let mm = mm.unwrap();
392
393        let mmm = match mm.0.clone() {
394            MsgLalaVersionEnum::V2(v) => v, _ => { panic!("Wrong enum, expected v2") }
395        };
396
397
398        assert_eq!(bits, mm.1);
399        assert_eq!(mv.base, mmm.base);
400        assert_eq!(mv.ext.v1, mmm.ext.v1);
401        assert_eq!(mv.ext.v2, mmm.ext.v2);
402
403        // ***
404        let mut der = Bides::from_biseri(&ser.clone());
405
406        let mm = MsgLalaVersionEnum::bit_deserialize(3, &mut der);
407        println!("v4 - mm: {:?}", mm);
408        assert!(mm.is_some());
409        let mm = mm.unwrap();
410
411        let mmm = match mm.0.clone() {
412            MsgLalaVersionEnum::V3(v) => v, _ => { panic!("Wrong enum, expected v3") }
413        };
414
415        assert_eq!(bits, mm.1);
416        assert_eq!(mv.base, mmm.base);
417        assert_eq!(mv.ext.v2, mmm.ext.v2);
418        assert_eq!(mv.ext.v3, mmm.ext.v3);
419    }
420}
bitis_lib/lib.rs

bitis_lib/
lib.rs
