bitcram 0.3.0

A small, derive-based bit packing library for compact integer representations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::fmt::Debug;

use bitcram::{Packable, packable};

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct U3(pub u8);
impl Packable<u128> for U3 {
    const SIZE: u32 = 3;
    fn pack(&self) -> u128 {
        self.0 as u128
    }
    fn unpack(buffer: u128) -> Self {
        Self(buffer as u8)
    }
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct U64v(pub u64);
impl Packable<u128> for U64v {
    const SIZE: u32 = 64;
    fn pack(&self) -> u128 {
        self.0 as u128
    }
    fn unpack(buffer: u128) -> Self {
        Self(buffer as u64)
    }
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Nibble(pub u8);
impl Packable<u8> for Nibble {
    const SIZE: u32 = 4;
    fn pack(&self) -> u8 {
        self.0
    }
    fn unpack(buffer: u8) -> Self {
        Self(buffer)
    }
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub struct UnitStruct;

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub struct TupleStruct(pub U3, pub U3, pub UnitStruct);

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub struct NamedStruct {
    pub x: U3,
    pub y: U3,
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub enum MixedEnum {
    UnitVariant,
    EmptyTuple(),
    Tuple(U3, TupleStruct),
    Named { x: UnitStruct, y: TupleStruct },
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub enum SingleVariantEnum {
    Only,
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub struct GenericPair<T: Clone>
where
    T: Debug,
{
    pub x: T,
    pub y: T,
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
#[allow(dead_code)]
pub enum EmptyEnum {}

#[packable(u8)]
#[derive(Debug, PartialEq, Eq)]
pub struct FullU8 {
    pub hi: Nibble,
    pub lo: Nibble,
}

#[packable(u128)]
#[derive(Debug, PartialEq, Eq)]
pub struct FullU128 {
    pub hi: U64v,
    pub lo: U64v,
}

#[packable(u32)]
#[derive(Debug, PartialEq, Eq)]
pub struct BitsStruct {
    #[bits(5)]
    pub x: u8,
    #[bits(5)]
    pub y: u8,
    #[bits(3)]
    pub z: u8,
}

#[packable(u16)]
#[derive(Debug, PartialEq, Eq)]
pub struct BitsTuple(#[bits(4)] pub u8, #[bits(4)] pub u8);

#[packable(u32)]
#[derive(Debug, PartialEq, Eq)]
pub enum BitsEnum {
    Empty,
    Value(#[bits(8)] u8),
    Pair {
        #[bits(4)]
        a: u8,
        b: bool,
    },
}

#[packable(u16, u32, u64)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MultiBuffer {
    #[bits(5)]
    pub x: u8,
    #[bits(5)]
    pub y: u8,
}