bitis_lib/lib_impl/
berde.rs

1use std::ops::{AddAssign, Neg, Shl, Shr};
2use std::convert::{TryFrom, From, TryInto};
3use std::fmt::Display;
4
5// ***
6pub trait IntegerBaseFunctions {
7    const IS_SIGNED: bool;
8    fn get_absolute_uint(self: &Self) -> u64;
9    fn is_val_negative(self: &Self) -> bool;
10    fn switch_sign_if_possible(self: &Self) -> Self;
11    fn get_zero() -> Self;
12}
13macro_rules! impl_integer_signed {
14    ($type:ty) => {
15        impl IntegerBaseFunctions for $type {
16            const IS_SIGNED: bool = true;
17            fn get_absolute_uint(self: &Self) -> u64 {
18                if *self < 0 { self.clone().neg() as u64 }
19                else { self.clone() as u64 }
20            }
21            fn is_val_negative(self: &Self) -> bool { *self < 0 }
22            fn switch_sign_if_possible(self: &Self) -> Self { return self.clone().neg() }
23            fn get_zero() -> Self { 0 as $type }
24        }
25} }
26macro_rules! impl_integer_unsigned {
27    ($type:ty) => {
28        impl IntegerBaseFunctions for $type {
29            const IS_SIGNED: bool = false;
30            fn get_absolute_uint(self: &Self) -> u64 { self.clone() as u64 }
31            fn is_val_negative(self: &Self) -> bool { false }
32            fn switch_sign_if_possible(self: &Self) -> Self { return self.clone() }
33            fn get_zero() -> Self { 0 as $type }
34        }
35} }
36impl_integer_signed!(i8);
37impl_integer_signed!(i16);
38impl_integer_signed!(i32);
39impl_integer_signed!(i64);
40impl_integer_unsigned!(u8);
41impl_integer_unsigned!(u16);
42impl_integer_unsigned!(u32);
43impl_integer_unsigned!(u64);
44
45// ***
46#[derive(Debug, Clone)]
47pub struct Biseri {
48    cur_cache_u8: u16,
49    sub_byte_counter: u8,
50    data_cache: Vec<u8>,
51    final_total_bits: u64,
52}
53
54fn bits_for_and(x: u8) -> u16 {
55    u16::MAX >> (u16::BITS as u8 - x)
56}
57
58#[allow(dead_code)]
59pub trait BiserdiTraitVarBitSize : Sized {
60    fn bit_serialize(self: &Self, total_bits: u64, biseri: &mut Biseri) -> Option<u64>;
61    fn bit_deserialize(version_id: u16, total_bits: u64, bides: &mut Bides) -> Option<(Self, u64)>;
62}
63#[allow(dead_code)]
64pub trait BiserdiTrait: Sized {
65    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64>;
66    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)>;
67}
68
69#[allow(dead_code)]
70impl Biseri {
71    pub fn new() -> Biseri {
72        Biseri { cur_cache_u8: 0, data_cache: Vec::new(), sub_byte_counter: 0, final_total_bits: 0 }
73    }
74
75    pub fn data_size_bytes(&self) -> u64 {
76        self.data_cache.len() as u64
77    }
78    pub fn get_data(&self) -> &Vec<u8> {
79        &self.data_cache
80    }
81
82    fn add_data_base_u8(&mut self, cur_u8: &u8, total_bits: u64) -> u64 {
83        if total_bits > 0 {
84            let cur_u16 = cur_u8.clone() as u16;
85            let shift_by = self.sub_byte_counter & 7;
86
87            let cur_bit_size = std::cmp::min(8, total_bits as u8);
88            // println!("cur_bit_size: {}", cur_bit_size);
89            let cur_u16 = (cur_u16 & (bits_for_and(cur_bit_size))) << shift_by;
90            self.cur_cache_u8 += cur_u16;
91
92            self.sub_byte_counter += cur_bit_size;
93            let total_bits = total_bits - cur_bit_size as u64;
94
95            if self.sub_byte_counter >= 8 {
96                self.sub_byte_counter -= 8;
97                let u8_to_add = (self.cur_cache_u8 & 0xFF) as u8;
98                self.data_cache.push(u8_to_add);
99                self.cur_cache_u8 >>= 8;
100            }
101            total_bits
102        }
103        else { 0 }
104    }
105
106    pub fn add_data(&mut self, cur_data: &Vec<u8>, total_bits: u64) -> Option<u64> {
107        // if (cur_data.len() as u64)*8 > total_bits {
108        //     // return None;
109        //     println!("")
110        // }
111        // if (cur_data.len() as u64)*8  < total_bits {
112        //     return None;
113        // }
114        let mut cur_total_bits = total_bits;
115        for cu8 in cur_data.iter() {
116            cur_total_bits = self.add_data_base_u8(cu8, cur_total_bits);
117        }
118        Some(total_bits)
119    }
120
121    pub fn add_biseri_data(&mut self, data: &Biseri) -> Option<u64> {
122        self.add_data(&data.data_cache, data.final_total_bits)
123        // self.add_data(&data.data_cache, ((data.data_cache.len() << 3) +
124        //     data.sub_byte_counter as usize) as u64)
125    }
126    pub fn finish_add_data(&mut self) -> Option<(u64, u64)> {
127        if self.final_total_bits > 0 {
128            None
129        }
130        else {
131            let total_bits = ((self.data_cache.len() as u64) << 3) + self.sub_byte_counter as u64;
132            if self.sub_byte_counter > 0 {
133                let u8_to_add = (self.cur_cache_u8 & 0xFF) as u8;
134                self.data_cache.push(u8_to_add);
135            }
136
137            self.final_total_bits = total_bits;
138            Some((total_bits, self.data_cache.len() as u64))
139        }
140    }
141}
142
143#[derive(Debug, Clone)]
144pub struct Bides {
145    cur_read_pos: u64,
146    sub_byte_counter: u8,
147    data_cache: Vec<u8>,
148}
149#[allow(dead_code)]
150impl Bides {
151    pub fn from_vec(data: &Vec<u8>) -> Bides {
152        Bides{sub_byte_counter: 0, data_cache: data.clone(), cur_read_pos: 0}
153    }
154    pub fn from_biseri(biseri: &Biseri) -> Bides {
155        Bides{sub_byte_counter: 0, data_cache: biseri.get_data().clone(), cur_read_pos: 0}
156    }
157
158    pub fn decode_data_base_u8(&mut self, total_bits: u64) -> Option<(u8, u64)> {
159        if self.cur_read_pos as usize >= self.data_cache.len() { return None}
160        let mut cur_u16: u16 = self.data_cache[self.cur_read_pos as usize] as u16;
161        if (self.cur_read_pos + 1 < self.data_cache.len() as u64) && (self.sub_byte_counter > 0) {
162            cur_u16 += (self.data_cache[(self.cur_read_pos + 1) as usize] as u16) << 8;
163        }
164
165        let cur_used_bits = std::cmp::min(total_bits as u8, 8);
166
167        // println!("d cur_used_bits={} (total_bits={})", cur_used_bits, total_bits);
168
169        let d = ((cur_u16 >> self.sub_byte_counter) & bits_for_and(cur_used_bits)) as u8;
170
171        self.sub_byte_counter += cur_used_bits;
172        if self.sub_byte_counter >= 8 {
173            self.sub_byte_counter -= 8;
174            self.cur_read_pos += 1;
175        }
176
177        Some((d, total_bits - cur_used_bits as u64))
178    }
179
180    pub fn decode_data(&mut self, total_bits: u64, expected_bytes: u32) -> Option<Vec<u8>> {
181        if self.cur_read_pos >= self.data_cache.len() as u64 {
182            return None;
183        }
184        let mut cur_total_bits = total_bits;
185        let mut dv = Vec::new();
186        while cur_total_bits > 0 {
187            let d;
188            (d, cur_total_bits) = match self.decode_data_base_u8(cur_total_bits) {
189                Some(d) => d, None => { return None; }
190            };
191            dv.push(d);
192        }
193        let num_add = expected_bytes - dv.len() as u32;
194        for _ in 0..num_add { dv.push(0); }
195        Some(dv)
196    }
197
198    pub fn skip_bits(&mut self, bits: u64) {
199        let bits_total_pos = bits + self.sub_byte_counter as u64;
200        self.sub_byte_counter = (bits_total_pos.clone() & 7) as u8;
201        self.cur_read_pos += bits_total_pos >> 3;
202    }
203}
204
205macro_rules! impl_biserdi_var_bitsize_trait {
206    ($type:ty, $num_bytes: expr) => {
207        impl BiserdiTraitVarBitSize for $type {
208            fn bit_serialize(self: &Self, total_bits: u64, biseri: &mut Biseri) -> Option<u64> {
209                if Self::IS_SIGNED { self.is_val_negative().bit_serialize(biseri)?; }
210                let v = self.get_absolute_uint();
211                let vv = &v.to_le_bytes().to_vec();
212                let bits = biseri.add_data(vv, total_bits)?;
213
214                let bits_with_sign = if Self::IS_SIGNED { bits+1 } else { bits };
215                Some(bits_with_sign)
216            }
217            fn bit_deserialize(version_id: u16, total_bits: u64, bides: &mut Bides) -> Option<(Self, u64)> {
218                let is_neg = if Self::IS_SIGNED {
219                    bool::bit_deserialize(version_id, bides)?.0 }
220                else { false };
221
222                let mut v = Self::from_le_bytes(
223                    bides.decode_data(total_bits, $num_bytes)?.try_into().ok()?);
224                if is_neg { v = v.switch_sign_if_possible() }
225
226                let bits_with_sign = if Self::IS_SIGNED { total_bits + 1 } else { total_bits };
227                Some((v, bits_with_sign))
228            }
229        }
230    };
231}
232macro_rules! impl_biserdi {
233    ($type:ty, $num_bits: expr) => {
234        impl BiserdiTrait for $type {
235            fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
236                Some(biseri.add_data(&self.clone().to_le_bytes().to_vec(), ($num_bits))?)
237            }
238            fn bit_deserialize(_version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
239                Some((Self::from_le_bytes(bides.decode_data(
240                    ($num_bits), std::cmp::max((($num_bits)>>3),1))?.try_into().ok()?),
241                $num_bits))
242            }
243        }
244    };
245}
246
247impl BiserdiTrait for bool {
248    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
249        let val = if *self { 1_u8 } else { 0_u8 };
250        biseri.add_data_base_u8(&val, 1);
251        Some(1)
252    }
253    fn bit_deserialize(_version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
254        let vec = bides.decode_data(1, 1)?;
255        Some((if vec[0] == 0 { false } else { true }, 1))
256    }
257}
258impl_biserdi_var_bitsize_trait!(u8, u8::BITS>>3);
259impl_biserdi_var_bitsize_trait!(u16, u16::BITS>>3);
260impl_biserdi_var_bitsize_trait!(u32, u32::BITS>>3);
261impl_biserdi_var_bitsize_trait!(u64, u64::BITS>>3);
262impl_biserdi_var_bitsize_trait!(i8, i8::BITS>>3);
263impl_biserdi_var_bitsize_trait!(i16, i16::BITS>>3);
264impl_biserdi_var_bitsize_trait!(i32, i32::BITS>>3);
265impl_biserdi_var_bitsize_trait!(i64, i64::BITS>>3);
266impl_biserdi!(f32, 32);
267impl_biserdi!(f64, 64);
268
269impl<T> BiserdiTrait for Option<T> where T: BiserdiTrait + Default + Copy {
270    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
271        let mut size = 1;
272        match self {
273            None => { false.bit_serialize(biseri)?; },
274            Some(v) => {
275                true.bit_serialize(biseri)?;
276                size += v.bit_serialize(biseri)?;
277            }
278        }
279        Some(size)
280    }
281    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
282        let mut size = 1;
283
284        let (is_set, _) = bool::bit_deserialize(version_id, bides)?;
285        let v = if is_set {
286            let vv = T::bit_deserialize(version_id, bides)?;
287            size += vv.1.clone();
288            Some(vv.0)
289        }
290        else { None };
291
292        Some((v, size))
293    }
294}
295
296/* impl<T, const N: usize> BiserdiTrait for [T; N] where T: BiserdiTrait + Default + Copy {
297    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
298        let mut s = 0;
299        for i in 0..N { s += self[i].bit_serialize(biseri)?; }
300        Some(s)
301    }
302    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
303        let mut v: Self = [T::default(); N];
304        let mut bits = 0;
305        let mut cur_bits;
306        for i in 0..N { (v[i], cur_bits) = T::bit_deserialize(version_id, bides)?; bits += cur_bits; }
307        Some((v, bits))
308    }
309}
310impl<T, const N: usize> BiserdiTraitVarBitSize for [T; N] where T: BiserdiTraitVarBitSize + Default + Copy {
311    fn bit_serialize(self: &Self, total_bits_per_unit: u64, biseri: &mut Biseri) -> Option<u64> {
312        let mut s = 0;
313        for i in 0..N {
314            s += self[i].bit_serialize(total_bits_per_unit, biseri)?;
315        }
316        Some(s)
317    }
318    fn bit_deserialize(version_id: u16, total_bits_per_unit: u64, bides: &mut Bides) -> Option<(Self, u64)> {
319        let mut v: Self = [T::default(); N];
320        let mut bits = 0;
321        let mut cur_bits;
322        for i in 0..N {
323            (v[i], cur_bits) = T::bit_deserialize(version_id, total_bits_per_unit, bides)?; bits += cur_bits; }
324        Some((v, bits))
325    }
326} */
327
328#[derive(Debug, Clone, PartialEq, Eq, Copy)]
329pub struct FixedArray<T, const N: usize> { pub val: [T; N] }
330impl<T, const N: usize> BiserdiTrait for FixedArray<T, N> where T: BiserdiTrait + Default + Copy {
331    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
332        let mut s = 0;
333        for i in 0..N { s += self.val[i].bit_serialize(biseri)?; }
334        Some(s)
335    }
336    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
337        let mut v: [T; N] = [T::default(); N];
338        let mut bits = 0;
339        let mut cur_bits;
340        for i in 0..N { (v[i], cur_bits) = T::bit_deserialize(version_id, bides)?; bits += cur_bits; }
341        Some((Self{ val: v}, bits))
342    }
343}
344impl<T, const N: usize> BiserdiTraitVarBitSize for FixedArray<T, N> where T: BiserdiTraitVarBitSize + Default + Copy {
345    fn bit_serialize(self: &Self, total_bits_per_unit: u64, biseri: &mut Biseri) -> Option<u64> {
346        let mut s = 0;
347        for i in 0..N {
348            s += self.val[i].bit_serialize(total_bits_per_unit, biseri)?;
349        }
350        Some(s)
351    }
352    fn bit_deserialize(version_id: u16, total_bits_per_unit: u64, bides: &mut Bides) -> Option<(Self, u64)> {
353        let mut v = [T::default(); N];
354        let mut bits = 0;
355        let mut cur_bits;
356        for i in 0..N {
357            (v[i], cur_bits) = T::bit_deserialize(version_id, total_bits_per_unit, bides)?; bits += cur_bits; }
358        Some((Self{ val: v}, bits))
359    }
360}
361impl<T: Sized + Copy + BiserdiTrait, const N: usize> From<[T; N]> for FixedArray<T, N> {
362    fn from(val: [T;N]) -> Self { Self{ val: val.clone()} } }
363impl<T: Sized + Copy + Display, const N: usize> std::fmt::Display for FixedArray<T, N> {
364    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
365        let das: Vec<String> = self.val.iter().map(|v| format!("{}", v)).collect();
366        write!(f, "[{}]", das.join(", "))
367    } }
368
369pub struct DynArray<T, const DYNSIZEBITS: u8> { pub val: Vec<T> }
370impl<T, const DYNSIZEBITS: u8> BiserdiTrait for DynArray<T, DYNSIZEBITS> where T: BiserdiTrait + Default + Copy {
371    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
372        let mut s = 0;
373        s += DynInteger::<u32, DYNSIZEBITS>::new(self.val.len() as u32).bit_serialize(biseri)?;
374        for d in self.val.iter() { s += d.bit_serialize(biseri)?; };
375        Some(s)
376    }
377    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
378        let mut s = 0;
379        let (v, cs) =
380            DynInteger::<u32, DYNSIZEBITS>::bit_deserialize(version_id, bides)?;
381        let mut data = Vec::with_capacity(cs as usize);
382        for _ci in 0..v.val {
383            let (vi, si) = T::bit_deserialize(version_id, bides)?;
384            s += si;
385            data.push(vi);
386        }
387        Some((Self{ val: data }, s+cs))
388    }
389}
390impl<T: Sized + Copy + BiserdiTraitVarBitSize, const DYNSIZEBITS: u8, const N: usize> From<[T; N]> for DynArray<T, DYNSIZEBITS> {
391    fn from(val: [T;N]) -> Self {
392        DynArray{ val:Vec::from(val)}
393    } }
394impl<T: Sized + Copy + BiserdiTraitVarBitSize, const DYNSIZEBITS: u8> From<Vec<T>> for DynArray<T, DYNSIZEBITS> {
395    fn from(val: Vec<T>) -> Self {
396        DynArray{ val: val.clone()}
397    } }
398impl<T: Sized + Copy + BiserdiTraitVarBitSize + Display, const DYNSIZEBITS: u8> std::fmt::Display for DynArray<T, DYNSIZEBITS> {
399    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
400        let das: Vec<String> = self.val.iter().map(|v| v.to_string()).collect();
401        write!(f, "[{} |dynbits:{}]", das.join(", "), DYNSIZEBITS)
402    } }
403
404
405#[derive(Debug, Clone, PartialEq, Eq, Default, Copy)]
406pub struct VarWithGivenBitSize<T: Sized + Copy + BiserdiTraitVarBitSize, const NUM_BITS: u64> {
407    pub val: T
408}
409impl<T: Sized + Copy + BiserdiTraitVarBitSize, const NUM_BITS: u64> VarWithGivenBitSize<T, NUM_BITS> {
410    pub fn new(v: T) -> Self { VarWithGivenBitSize {val: v} }
411}
412impl<T: Sized + Copy + BiserdiTraitVarBitSize, const NUM_BITS: u64> From<T> for VarWithGivenBitSize<T, NUM_BITS> {
413    fn from(val: T) -> Self {
414        VarWithGivenBitSize::<T, NUM_BITS>::new(val)
415    }
416}
417impl<T: Sized + Copy + BiserdiTraitVarBitSize + Display, const NUM_BITS: u64> std::fmt::Display for VarWithGivenBitSize<T, NUM_BITS> {
418    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
419        write!(f, "{} |bits:{}", self.val, NUM_BITS)
420} }
421impl<T: Sized + Copy + BiserdiTraitVarBitSize, const NUM_BITS: u64> BiserdiTrait for VarWithGivenBitSize<T, NUM_BITS> {
422    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
423        self.val.bit_serialize(NUM_BITS, biseri)
424    }
425    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
426        let v = T::bit_deserialize(version_id, NUM_BITS, bides)?;
427        Some((Self{val: v.0}, v.1))
428    }
429}
430
431pub struct DynInteger<
432    T: Sized + Copy + BiserdiTraitVarBitSize + AddAssign + Shl<Output = T> + Shr + Ord + PartialEq + TryFrom<u64>
433    + IntegerBaseFunctions, const N: u8> {
434    pub val: T
435}
436impl<T: Display + Sized + Copy + BiserdiTraitVarBitSize + AddAssign + Shl<Output = T> + Shr + Ord + PartialEq + TryFrom<u64>
437    + IntegerBaseFunctions, const N: u8> DynInteger<T, N> {
438    const DYN_SIZE: u8 = N;
439    pub fn new(v: T) -> Self{
440        DynInteger{val: v}
441    }
442}
443impl<T: Display + Sized + Copy + BiserdiTraitVarBitSize + AddAssign + Shl<Output = T> + Shr + Ord + PartialEq + TryFrom<u64>
444    + IntegerBaseFunctions, const N: u8> BiserdiTrait for DynInteger<T, N> {
445    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
446        // let br = self.bits_required();
447        // let dyn_sections = br / Self::DYN_SIZE;
448        let mut bit_size: u64 = 1;
449        let mut val_work = self.val.get_absolute_uint();
450
451        if T::IS_SIGNED { self.val.is_val_negative().bit_serialize(biseri)?; bit_size +=1; }
452
453        (val_work != 0).bit_serialize(biseri);
454        while val_work > 0 {
455            val_work.bit_serialize(u64::from(Self::DYN_SIZE), biseri)?;
456            val_work >>= Self::DYN_SIZE;
457            bit_size += (Self::DYN_SIZE + 1) as u64;
458            let further_data = val_work > 0;
459            further_data.bit_serialize(biseri);
460        }
461        Some(bit_size)
462    }
463    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
464        let mut cur_shift: u64 = 0;
465        let mut v: u64 = 0;
466        let mut negative_sign = false;
467
468        let mut bit_size = 1;
469        if T::IS_SIGNED {
470            negative_sign = bool::bit_deserialize(version_id, bides)?.0; bit_size += 1; }
471        let mut further_data = bool::bit_deserialize(version_id, bides)?.0;
472        while further_data {
473            let vt = u64::bit_deserialize(version_id, Self::DYN_SIZE as u64, bides)?;
474            bit_size += vt.1 + 1;
475            v += vt.0 << cur_shift;
476            cur_shift += u64::from(Self::DYN_SIZE);
477            further_data = bool::bit_deserialize(version_id, bides)?.0;
478        }
479        let mut vv= T::try_from(v).ok()?;
480        if negative_sign {
481            vv = vv.switch_sign_if_possible();
482        }
483        Some((Self{val: vv}, bit_size))
484    }
485}
486impl<T: Display + Sized + Copy + BiserdiTraitVarBitSize + AddAssign + Shl<Output = T> + Shr + Ord + PartialEq + TryFrom<u64>
487    + IntegerBaseFunctions, const N: u8> Display for DynInteger<T, N> {
488    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
489        write!(f, "{} |dynbits:{}]", self.val, N)
490    } }
491
492// ***
493#[derive(Debug, Clone, PartialEq)]
494pub enum FixPrecisionVal {
495    Overflow,
496    Value(f64),
497    Underflow
498}
499#[derive(Debug, Clone, PartialEq)]
500pub struct FixPrecisionMinMax<const NUM_BITS: u8, const MIN_IVALUE: i64, const MAX_IVALUE: i64> {
501    pub val: FixPrecisionVal
502}
503impl<const NUM_BITS: u8, const MIN_IVALUE: i64, const MAX_IVALUE: i64> FixPrecisionMinMax<NUM_BITS, MIN_IVALUE, MAX_IVALUE> {
504    const MIN_VALUE: f64 = MIN_IVALUE as f64;
505    const MAX_VALUE: f64 = MAX_IVALUE as f64;
506    const RANGE_VALUE: f64 = Self::MAX_VALUE - Self::MIN_VALUE;
507    const MAX_INT_VALUE_FOR_BITS: u64 = (1_u64<<NUM_BITS) - 1_u64;
508    const MAX_VALUE_FOR_BITS: f64 = (Self::MAX_INT_VALUE_FOR_BITS - 1_u64) as f64;
509
510    pub fn new(val: f64) -> Self {
511        if val > Self::MAX_VALUE { FixPrecisionMinMax { val: FixPrecisionVal::Overflow } }
512        else if val < Self::MIN_VALUE { FixPrecisionMinMax { val: FixPrecisionVal::Underflow } }
513        else { FixPrecisionMinMax { val: FixPrecisionVal::Value(val) } }
514    }
515}
516impl<const NUM_BITS: u8, const MIN_IVALUE: i64, const MAX_IVALUE: i64> BiserdiTrait for FixPrecisionMinMax<NUM_BITS, MIN_IVALUE, MAX_IVALUE> {
517    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
518        let v = match self.val {
519            // i = (v-Min) / (Max-Min) * 253 + 1
520            FixPrecisionVal::Value(v) =>
521                ((v - Self::MIN_VALUE) / Self::RANGE_VALUE * Self::MAX_VALUE_FOR_BITS + 1.0) as u64,
522            FixPrecisionVal::Underflow => 0,
523            FixPrecisionVal::Overflow => Self::MAX_INT_VALUE_FOR_BITS
524        };
525        v.bit_serialize(NUM_BITS as u64, biseri)
526    }
527    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
528        // v = (i-1)/253 * (Max-Min) + Min
529        let (v, bits) = u64::bit_deserialize(version_id, NUM_BITS as u64, bides)?;
530        let vv = if v == 0 { FixPrecisionVal::Underflow }
531        else if v == Self::MAX_INT_VALUE_FOR_BITS { FixPrecisionVal::Overflow }
532        else {
533            FixPrecisionVal::Value(((v-1) as f64) / Self::MAX_VALUE_FOR_BITS
534                * Self::RANGE_VALUE + Self::MIN_VALUE)
535        };
536        Some((Self{val: vv}, bits))
537    }
538}
539impl<const NUM_BITS: u8, const MIN_IVALUE: i64, const MAX_IVALUE: i64> Display for FixPrecisionMinMax<NUM_BITS, MIN_IVALUE, MAX_IVALUE> {
540    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
541        match self.val {
542            FixPrecisionVal::Overflow => write!(f, "Overflow |dynbits:{}", NUM_BITS),
543            FixPrecisionVal::Underflow => write!(f, "Underflow |dynbits:{}", NUM_BITS),
544            FixPrecisionVal::Value(v) => write!(f, "{} |dynbits:{}", v, NUM_BITS)
545        }
546    } }
547
548// *****
549#[derive(Debug, Clone, PartialEq)]
550pub struct Binary<const DYNSIZEBITS: u8> {
551    pub val: Vec<u8>
552}
553impl<const DYNSIZEBITS: u8> Binary<DYNSIZEBITS> {
554    pub fn new(data: Vec<u8>) -> Self {
555        Self{ val: data }
556    }
557}
558impl<const DYNSIZEBITS: u8> BiserdiTrait for Binary<DYNSIZEBITS> {
559    fn bit_serialize(self: &Self, biseri: &mut Biseri) -> Option<u64> {
560        let mut s = 0;
561        s += DynInteger::<u32, DYNSIZEBITS>::new(self.val.len() as u32).bit_serialize(biseri)?;
562        for d in self.val.iter() { s += d.bit_serialize(8, biseri)?; };
563        Some(s)
564    }
565    fn bit_deserialize(version_id: u16, bides: &mut Bides) -> Option<(Self, u64)> {
566        let mut s = 0;
567        let (v, cs) =
568            DynInteger::<u32, DYNSIZEBITS>::bit_deserialize(version_id, bides)?;
569        let mut data = Vec::with_capacity(cs as usize);
570        for _ci in 0..v.val {
571            let (vi, si) = u8::bit_deserialize(version_id, 8, bides)?;
572            s += si;
573            data.push(vi);
574        }
575        Some((Self{ val: data }, s+cs))
576    }
577}
578impl<const N: u8> std::fmt::Display for Binary< N> {
579    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
580        let hex = self.val.iter().map(|b| format!("{:02x}", b).to_string()).collect::<Vec<String>>().join(" ");
581        write!(f, "{:x?} |dynbits:{}", hex, N)
582    }
583}
584
585#[cfg(test)]
586mod bitis_base_serialization_deserialization {
587    use rstest::rstest;
588    use crate::lib_impl::berde::{Bides, Biseri};
589    use super::*;
590
591    #[rstest]
592    fn add_one_u8() {
593        let mut b = Biseri::new();
594        let d = 0b10101010_u8;
595
596        b.add_data_base_u8(&d, 8);
597
598        assert_eq!(b.clone().data_cache.len(), 1);
599        assert_eq!(b.sub_byte_counter, 0);
600
601        let r = b.finish_add_data().unwrap();
602        assert_eq!(r, (8, 1));
603    }
604
605    #[rstest]
606    #[case::ot_uint4(4, 1, 4, 1)]
607    #[case::tt_uint4(4, 2, 8, 1)]
608    #[case::ot_uint6(6, 1, 6, 1)]
609    #[case::tt_uint6(6, 2, 12, 2)]
610    #[case::trt_uint6(6, 3, 18, 3)]
611    #[case::ft_uint6(6, 4, 24, 3)]
612    fn add_one_var(#[case] bitsize: u64, #[case] repeated: u8, #[case] final_bitsize: u64, #[case] num_bytes: u64) {
613        let mut b = Biseri::new();
614        let d = 0b10101010_u8;
615
616        for _i in 0..repeated {
617            b.add_data_base_u8(&d, bitsize);
618        }
619
620        let r = b.finish_add_data().unwrap();
621        assert_eq!(r, (final_bitsize, num_bytes));
622    }
623
624    #[rstest]
625    #[case::ok(5, 4, 5)]
626    #[case::expected_overflow(0b10011, 4, 3)]
627    fn serialize_and_deserialize_base(#[case] val_in: u8, #[case] bitsize: u64, #[case] val_out: u8) {
628        let mut ser = Biseri::new();
629
630        ser.add_data_base_u8(&val_in, bitsize);
631        ser.finish_add_data();
632
633        let mut des = Bides::from_biseri(&ser);
634
635        assert_eq!(des.data_cache, ser.data_cache);
636
637        let r = des.decode_data_base_u8(bitsize);
638        assert!(r.is_some());
639        let (dd, bs) = r.unwrap();
640        assert_eq!(bs, 0);
641
642        println!("val_in: {val_in} vs. dd: {dd} (expected: {val_out}");
643        assert_eq!(val_out, dd);
644    }
645
646    #[rstest]
647    #[case::ok(3*256+5, 16, 3*256+5)]
648    #[case::ok(3*256+5, 12, 3*256+5)]
649    #[case::ok(3*256+5, 9, 1*256+5)]
650    fn serialize_and_deserialize_u16_single(#[case] val_in: u16, #[case] bitsize: u64, #[case] val_out: u16) {
651        let val_in_vec = val_in.to_le_bytes().clone();
652
653        let mut ser = Biseri::new();
654
655        let mut total_size = bitsize;
656        val_in_vec.clone().iter().for_each(|x| {
657            total_size = ser.add_data_base_u8(&x, bitsize);
658        });
659        ser.finish_add_data();
660
661        println!("ser.cache: {:?}", ser.data_cache);
662
663        assert_eq!(ser.data_cache.len(), 2);
664
665        let mut des = Bides::from_biseri(&ser);
666
667        assert_eq!(des.data_cache, ser.data_cache);
668
669        let mut dd = Vec::new();
670        let mut total_size = bitsize;
671        while total_size > 0 {
672            let ddd;
673            let r = des.decode_data_base_u8(total_size);
674            assert!(r.is_some());
675            (ddd, total_size) = r.unwrap();
676            dd.push(ddd);
677        };
678
679        let ddv = u16::from_le_bytes(dd.clone().try_into().unwrap());
680        println!("val_in: {val_in} ({val_in_vec:?}) vs. ddv: {ddv:?} ({dd:?}) (expected: {val_out})");
681        assert_eq!(val_out, ddv);
682    }
683
684    fn add_two_u16_fixed(ser: &mut Biseri, bits: u64) -> (u64, u64) {
685        let d: u16 = 3;
686
687        ser.add_data(&d.to_le_bytes().to_vec(), bits);
688        ser.add_data(&d.to_le_bytes().to_vec(), bits);
689        ser.finish_add_data().unwrap()
690    }
691    #[rstest]
692    fn serialize_u16_fixed_full() {
693        let mut ser = Biseri::new();
694
695        let (lbits, lbytes) = add_two_u16_fixed(&mut ser, 16);
696
697        assert_eq!(ser.data_cache.len(), 4);
698        assert_eq!(lbytes, 4);
699        assert_eq!(lbits, 2 * 16);
700
701        assert_eq!(ser.data_cache[0], 3);
702        assert_eq!(ser.data_cache[1], 0);
703        assert_eq!(ser.data_cache[2], 3);
704        assert_eq!(ser.data_cache[3], 0);
705    }
706
707    #[rstest]
708    fn serialize_u16_fixed_12b() {
709        let mut ser = Biseri::new();
710
711        let (lbits, lbytes) = add_two_u16_fixed(&mut ser, 12);
712
713        assert_eq!(ser.data_cache.len(), 3);
714        assert_eq!(lbytes, 3);
715        assert_eq!(lbits, 2 * 12);
716
717        assert_eq!(ser.data_cache[0], 3);
718        assert_eq!(ser.data_cache[1], 3 << 4);
719        assert_eq!(ser.data_cache[2], 0);
720    }
721
722    #[rstest]
723    #[case::bitsize_16(16)]
724    #[case::bitsize_14(14)]
725    #[case::bitsize_12(12)]
726    fn ser_and_deserialize_u16_fixed(#[case] bits: u64) {
727        let mut ser = Biseri::new();
728
729        let (_lbits, _lbytes) = add_two_u16_fixed(&mut ser, bits);
730
731        let mut des = Bides::from_biseri(&ser);
732
733        assert_eq!(des.data_cache, ser.data_cache);
734
735        let d1 = des.decode_data(bits, 2);
736        assert!(d1.is_some());
737        let d2 = des.decode_data(bits, 2);
738        assert!(d2.is_some());
739
740        let d1 = d1.unwrap();
741        let d2 = d2.unwrap();
742
743        assert_eq!(d1[0], 3);
744        assert_eq!(d1[1], 0);
745        assert_eq!(d2[0], 3);
746        assert_eq!(d2[1], 0);
747    }
748
749    #[rstest]
750    fn ser_and_deserialize_i16_fixed() {
751        let mut ser = Biseri::new();
752
753        let v: i8 = -11;
754        v.bit_serialize(5, &mut ser);
755
756        let (bits, bytes) = ser.finish_add_data().unwrap();
757        println!("bits: {}, bytes: {}", bits, bytes);
758
759        let mut des = Bides::from_biseri(&ser);
760
761        let vv = i8::bit_deserialize(1,5, &mut des);
762        println!("v: {}, vv: {:?}", v, vv);
763
764        assert!(vv.is_some());
765
766        let vv = vv.unwrap();
767        println!("bits_des: {}", vv.1);
768        assert_eq!(v, vv.0);
769    }
770
771    #[rstest]
772    fn de_and_serialize_various_unsigned() {
773        // ***********************************************************
774        let mut ser = Biseri::new();
775        let v1: u8 = 5;
776        v1.bit_serialize(6, &mut ser);
777        // ser.add_data_u8(&v1, 6);
778        let v2: u16 = 15;
779        v2.bit_serialize(14, &mut ser);
780        // ser.add_data_u16(&v2, 14);
781        let v3: u32 = 55;
782        v3.bit_serialize(22, &mut ser);
783        // ser.add_data_u32(&v3, 30);
784        let (bits, bytes) = ser.finish_add_data().unwrap();
785        println!("bits: {}, bytes: {}", bits, bytes);
786
787        // // ***********************************************************
788        let mut des = Bides::from_biseri(&ser);
789        let vo1 = u8::bit_deserialize(1,6, &mut des);
790        // let vo1 = des.decode_data_u8(6);
791        let vo2 = u16::bit_deserialize(1,14, &mut des);
792        // let vo2 = des.decode_data_u16(14);
793        let vo3 = u32::bit_deserialize(1,22, &mut des);
794        // let vo3 = des.decode_data_u32(30);
795
796        println!("v1: {}, v2: {}, v3: {} vs vo1: {:?}, vo2: {:?}, vo3: {:?}", v1, v2, v3, vo1, vo2, vo3);
797
798        // ***********************************************************
799        assert!(vo1.is_some());
800        assert_eq!(v1, vo1.unwrap().0);
801
802        assert!(vo2.is_some());
803        assert_eq!(v2, vo2.unwrap().0);
804
805        assert!(vo3.is_some());
806        assert_eq!(v3, vo3.unwrap().0);
807    }
808
809    #[rstest]
810    fn de_and_serialize_various_float() {
811        // ***********************************************************
812        let mut ser = Biseri::new();
813        let v1: f32 = 56.78;
814        v1.bit_serialize(&mut ser);
815        // ser.add_data_f32(&v1);
816        let v2: u8 = 5;
817        v2.bit_serialize(5, &mut ser);
818        // ser.add_data_u8(&v2, 5);
819        let v3: bool = true;
820        v3.bit_serialize(&mut ser);
821        // ser.add_data_bool(&v3);
822        let v4: bool = false;
823        v4.bit_serialize(&mut ser);
824        // ser.add_data_bool(&v4);
825        v1.bit_serialize(&mut ser);
826        // ser.add_data_f32(&v1);
827        let (bits, bytes) = ser.finish_add_data().unwrap();
828
829        println!("bits: {}, bytes: {}", bits, bytes);
830
831        // ***********************************************************
832        let mut des = Bides::from_biseri(&ser);
833        let vo1 = f32::bit_deserialize(1, &mut des);
834        let vo2 = u8::bit_deserialize(1,5, &mut des);
835        let vo3 = bool::bit_deserialize(1,&mut des);
836        let vo4 = bool::bit_deserialize(1,&mut des);
837        let vo5 = f32::bit_deserialize(1,&mut des);
838        // let vo1 = des.decode_data_f32();
839        // let vo2 = des.decode_data_u8(5);
840        // let vo3 = des.decode_data_bool();
841        // let vo4 = des.decode_data_bool();
842        // let vo5 = des.decode_data_f32();
843
844        println!("vo1: {:?}, vo2: {:?}, vo3: {:?}, vo4: {:?}, vo4: {:?}", vo1, vo2, vo3, vo4, vo5);
845
846        // ***********************************************************
847        assert!(vo1.is_some());
848        assert_eq!(v1, vo1.unwrap().0);
849
850        assert!(vo2.is_some());
851        assert_eq!(v2, vo2.unwrap().0);
852
853        assert!(vo3.is_some());
854        assert_eq!(v3, vo3.unwrap().0);
855
856        assert!(vo4.is_some());
857        assert_eq!(v4, vo4.unwrap().0);
858
859        assert!(vo5.is_some());
860        assert_eq!(v1, vo5.unwrap().0);
861    }
862
863    #[rstest]
864    fn serialize_and_deserialize_array_uint() {
865        let mut ser = Biseri::new();
866
867        let v: FixedArray<VarWithGivenBitSize<u16, 5>, 4> = [11.into(), 12.into(), 22.into(), 23.into()].into();
868        v.bit_serialize(&mut ser);
869        let (bits, bytes) = ser.finish_add_data().unwrap();
870        println!("bits: {}, bytes: {}", bits, bytes);
871
872        let mut des = Bides::from_biseri(&ser);
873        let vv = FixedArray::<VarWithGivenBitSize<u16, 5>, 4>::bit_deserialize(1,&mut des);
874
875        assert!(vv.is_some());
876        let vv = vv.unwrap().0;
877
878        assert_eq!(v.val[0], vv.val[0]);
879        assert_eq!(v.val[1], vv.val[1]);
880        assert_eq!(v.val[2], vv.val[2]);
881        assert_eq!(v.val[3], vv.val[3]);
882    }
883
884    #[rstest]
885    fn serialize_and_deserialize_array_bool() {
886        let mut ser = Biseri::new();
887
888        let v= FixedArray::from([true, true, false, true]);
889        v.bit_serialize(&mut ser);
890        let (bits, bytes) = ser.finish_add_data().unwrap();
891        println!("bits: {}, bytes: {}", bits, bytes);
892
893        let mut des = Bides::from_biseri(&ser);
894        let vv = FixedArray::<bool, 4>::bit_deserialize(1,&mut des);
895
896        assert!(vv.is_some());
897        let vv = vv.unwrap().0;
898
899        assert_eq!(v.val[0], vv.val[0]);
900        assert_eq!(v.val[1], vv.val[1]);
901        assert_eq!(v.val[2], vv.val[2]);
902        assert_eq!(v.val[3], vv.val[3]);
903    }
904    #[rstest]
905    fn serialize_and_deserialize_array_f64() {
906        let mut ser = Biseri::new();
907
908        let v = FixedArray::from([1.1, 1.2, 22.34, 123456.78]);
909        v.bit_serialize(&mut ser);
910        let (bits, bytes) = ser.finish_add_data().unwrap();
911        println!("bits: {}, bytes: {}", bits, bytes);
912
913        let mut des = Bides::from_biseri(&ser);
914        let vv = FixedArray::<f64, 4>::bit_deserialize(1,&mut des);
915
916        assert!(vv.is_some());
917        let vv = vv.unwrap().0;
918
919        assert_eq!(v.val[0], vv.val[0]);
920        assert_eq!(v.val[1], vv.val[1]);
921        assert_eq!(v.val[2], vv.val[2]);
922        assert_eq!(v.val[3], vv.val[3]);
923    }
924
925    #[rstest]
926    #[case::val_0(0, 1, 1)]
927    #[case::val_1(1, 5, 1)]
928    #[case::val_10(10, 9, 2)]
929    fn serialize_dyn_int_u32_3(#[case] val: u32, #[case] ex_bits: u64, #[case] ex_bytes: u64) {
930        // #[test]
931        // fn serialize_dyn_int_u32_3() {
932        //     let val: u32 = 10;
933        //     let ex_bits: u64 = 9;
934        //     let ex_bytes: u64 = 2;
935
936        let mut ser = Biseri::new();
937
938        let v = DynInteger::<u32, 3>::new(val);
939        v.bit_serialize(&mut ser);
940        let (bits, bytes) = ser.finish_add_data().unwrap();
941        println!("bits: {}, bytes: {}", bits, bytes);
942
943        assert_eq!(bits, ex_bits);
944        assert_eq!(bytes, ex_bytes);
945    }
946
947    #[rstest]
948    #[case::val_0(0, 2, 1)]
949    #[case::val_1(1, 6, 1)]
950    #[case::val_10(10, 10, 2)]
951    fn serialize_dyn_int_i32_3(#[case] val: i32, #[case] ex_bits: u64, #[case] ex_bytes: u64) {
952        // #[test]
953        // fn serialize_dyn_int_i32_3() {
954        //     let val: i32 = -1;
955        //     let ex_bits: u64 = 6;
956        //     let ex_bytes: u64 = 1;
957
958        let mut ser = Biseri::new();
959
960        let v = DynInteger::<i32, 3>::new(val);
961        v.bit_serialize(&mut ser);
962        let (bits, bytes) = ser.finish_add_data().unwrap();
963        println!("bits: {}, bytes: {}", bits, bytes);
964
965        assert_eq!(bits, ex_bits);
966        assert_eq!(bytes, ex_bytes);
967    }
968
969    #[rstest]
970    #[case::val_0(0)]
971    #[case::val_1(1)]
972    #[case::val_10(10)]
973    #[case::val_m1(-1)]
974    #[case::val_m1111(-1111)]
975    fn ser_and_deserialize_dyn_int_i32_3(#[case] val: i32) {
976        // #[test]
977        // fn ser_and_deserialize_dyn_int_i32_3() {
978        //     let val: i32 = -111;
979
980        let mut ser = Biseri::new();
981
982        let v = DynInteger::<i32, 3>::new(val);
983        v.bit_serialize(&mut ser);
984        let (bits, bytes) = ser.finish_add_data().unwrap();
985        println!("bits: {}, bytes: {}", bits, bytes);
986
987        let mut der = Bides::from_biseri(&ser);
988
989        let dv = DynInteger::<i32, 3>::bit_deserialize(1, &mut der);
990        assert!(dv.is_some());
991
992        let dv = dv.unwrap();
993        assert_eq!(val, dv.0.val);
994    }
995
996    #[rstest]
997    fn ser_and_deserialize_fixed_int() {
998        let mut ser = Biseri::new();
999
1000        let v = VarWithGivenBitSize::<u32, 20>::new(1111);
1001        v.bit_serialize(&mut ser);
1002
1003        let (bits, bytes) = ser.finish_add_data().unwrap();
1004        println!("bits: {}, bytes: {}", bits, bytes);
1005
1006        let mut der = Bides::from_biseri(&ser);
1007        let vv = VarWithGivenBitSize::<u32, 20>::bit_deserialize(1, &mut der);
1008
1009        println!("v: {:?}, vv: {:?}", v, vv);
1010        assert!(vv.is_some());
1011        let vv = vv.unwrap().0;
1012
1013        assert_eq!(v.val, vv.val);
1014    }
1015
1016    #[rstest]
1017    fn ser_and_deserialize_fixed_precision_1() {
1018        let mut ser = Biseri::new();
1019
1020        let v = FixPrecisionMinMax::<20, -50, 50>::new(12.3456);
1021        v.bit_serialize(&mut ser);
1022
1023        let (bits, bytes) = ser.finish_add_data().unwrap();
1024        println!("bits: {}, bytes: {}", bits, bytes);
1025
1026        let mut der = Bides::from_biseri(&ser);
1027        let vv = FixPrecisionMinMax::<20, -50, 50>::bit_deserialize(1, &mut der);
1028
1029        println!("v: {:?}, vv: {:?}", v, vv);
1030        assert!(vv.is_some());
1031        let vv = vv.unwrap().0;
1032
1033        let eps = 1e-1;
1034        match v.val {
1035            FixPrecisionVal::Value(fpv) => {
1036                match vv.val {
1037                    FixPrecisionVal::Value(fpvv) => assert!((fpv - fpvv).abs() < eps),
1038                    _ => assert!(false)
1039                }
1040            },
1041            _ => assert!(false)
1042        }
1043    }
1044    #[rstest]
1045    fn ser_and_deserialize_fixed_precision_2() {
1046        let mut ser = Biseri::new();
1047
1048        let v = FixPrecisionMinMax::<20, -50, 50>::new(-12.3456);
1049        v.bit_serialize(&mut ser);
1050
1051        let (bits, bytes) = ser.finish_add_data().unwrap();
1052        println!("bits: {}, bytes: {}", bits, bytes);
1053
1054        let mut der = Bides::from_biseri(&ser);
1055        let vv = FixPrecisionMinMax::<20, -50, 50>::bit_deserialize(1, &mut der);
1056
1057        println!("v: {:?}, vv: {:?}", v, vv);
1058        assert!(vv.is_some());
1059        let vv = vv.unwrap().0;
1060
1061        let eps = 1e-1;
1062        match v.val {
1063            FixPrecisionVal::Value(fpv) => {
1064                match vv.val {
1065                    FixPrecisionVal::Value(fpvv) => assert!((fpv - fpvv).abs() < eps),
1066                    _ => assert!(false)
1067                }
1068            },
1069            _ => assert!(false)
1070        }
1071    }
1072    #[rstest]
1073    fn ser_and_deserialize_fixed_precision_under() {
1074        let mut ser = Biseri::new();
1075
1076        let v = FixPrecisionMinMax::<10, -50, 50>::new(-60.0);
1077        v.bit_serialize(&mut ser);
1078
1079        let (bits, bytes) = ser.finish_add_data().unwrap();
1080        println!("bits: {}, bytes: {}", bits, bytes);
1081
1082        let mut der = Bides::from_biseri(&ser);
1083        let vv = FixPrecisionMinMax::<10, -50, 50>::bit_deserialize(1, &mut der);
1084
1085        println!("v: {:?}, vv: {:?}", v, vv);
1086        assert!(vv.is_some());
1087        let vv = vv.unwrap().0;
1088
1089        match vv.val {
1090            FixPrecisionVal::Underflow => assert!(true),
1091            _ => assert!(false),
1092        }
1093    }
1094    #[rstest]
1095    fn ser_and_deserialize_fixed_precision_over() {
1096        let mut ser = Biseri::new();
1097
1098        let v = FixPrecisionMinMax::<10, -50, 50>::new(60.0);
1099        v.bit_serialize(&mut ser);
1100
1101        let (bits, bytes) = ser.finish_add_data().unwrap();
1102        println!("bits: {}, bytes: {}", bits, bytes);
1103
1104        let mut der = Bides::from_biseri(&ser);
1105        let vv = FixPrecisionMinMax::<10, -50, 50>::bit_deserialize(1, &mut der);
1106
1107        println!("v: {:?}, vv: {:?}", v, vv);
1108        assert!(vv.is_some());
1109        let vv = vv.unwrap().0;
1110
1111        match vv.val {
1112            FixPrecisionVal::Overflow => assert!(true),
1113            _ => assert!(false)
1114        }
1115    }
1116}
1117
bitis_lib/lib_impl/berde.rs

bitis_lib/lib_impl/
berde.rs
