bitcode 0.3.4

bitcode is a bitwise binary serializer
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

// Exports for derive macro. #[doc(hidden)] because not stable between versions.

pub use crate::code::*;
pub use crate::encoding::*;
pub use crate::nightly::{max, min};
pub use crate::read::Read;
pub use crate::register_buffer::RegisterBuffer;
pub use crate::write::Write;
pub use crate::Error;

#[cfg(any(test, feature = "serde"))]
pub use crate::serde::de::deserialize_compat;
#[cfg(any(test, feature = "serde"))]
pub use crate::serde::ser::serialize_compat;
#[cfg(any(test, feature = "serde"))]
pub use serde::{de::DeserializeOwned, Serialize};

// TODO only define once.
pub type Result<T> = std::result::Result<T, Error>;

pub fn invalid_variant() -> Error {
    crate::E::Invalid("enum variant").e()
}

#[cfg(all(test, debug_assertions))]
mod tests {
    use crate::{Decode, Encode};

    #[derive(Debug, PartialEq, Encode, Decode)]
    #[bitcode(recursive)]
    struct Recursive {
        a: Option<Box<Recursive>>,
        b: Option<Box<Self>>,
    }

    trait ParamTrait {
        type Bar: Encode + Decode;
    }

    #[derive(Encode, Decode)]
    struct Param<T: ParamTrait> {
        a: Option<T::Bar>,
    }

    #[derive(Debug, PartialEq, Encode, Decode)]
    struct Empty;

    #[derive(Debug, PartialEq, Encode, Decode)]
    struct Tuple(usize, u8);

    #[derive(Debug, PartialEq, Encode, Decode)]
    struct Generic<T>(usize, T);

    #[derive(Debug, PartialEq, Encode, Decode)]
    struct FooInner {
        foo: u8,
        #[bitcode_hint(gamma)]
        bar: usize,
        baz: String,
    }

    #[derive(Debug, PartialEq, Encode, Decode)]
    #[allow(unused)]
    enum Foo {
        #[bitcode_hint(frequency = 100)]
        A,
        #[bitcode_hint(frequency = 10)]
        B(String),
        C {
            #[bitcode_hint(gamma)]
            baz: usize,
            qux: f32,
        },
        #[bitcode_hint(fixed)]
        Foo(FooInner, #[bitcode_hint(gamma)] i64),
        #[bitcode_hint(expected_range = "0..10")]
        Tuple(Tuple),
        Empty(Empty),
    }

    #[derive(Encode, Decode)]
    enum Never {}

    #[derive(Copy, Clone, Debug, PartialEq, Encode, Decode)]
    enum XYZ {
        #[bitcode_hint(frequency = 2)]
        X,
        Y,
        Z,
    }

    #[test]
    fn test_encode_x() {
        let v = [XYZ::X; 16];
        let encoded = crate::encode(&v).unwrap();
        assert_eq!(encoded.len(), 2);

        let decoded: [XYZ; 16] = crate::decode(&encoded).unwrap();
        assert_eq!(v, decoded);
    }

    #[test]
    fn test_encode_y() {
        let v = [XYZ::Y; 16];
        let encoded = crate::encode(&v).unwrap();
        assert_eq!(encoded.len(), 4);

        let decoded: [XYZ; 16] = crate::decode(&encoded).unwrap();
        assert_eq!(v, decoded);
    }
}