bitcraft 0.9.4

A zero-cost, hardware-aligned bitfield and enumeration generator.
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

use bitcraft::byteval;

// 3 * u16 = 6 bytes (48 bits)
byteval! {
    pub struct Id48(3, u16);
}

// 2 * u32 = 8 bytes (64 bits)
byteval! {
    struct Id64(2, u32);
}

// Custom alignment (manual attribute)
byteval! {
    #[repr(align(2))]
    struct AlignedId48(3, u16);
}

byteval! {
    #[repr(align(8))]
    struct AlignedId64(2, u32);
}

// Shorthand (defaults to u8)
byteval! {
    struct Id24(3);
}

byteval! {
    struct SignedId24(i 3);
}

byteval! {
    struct SignedId48(i 3, u16);
}

#[test]
fn test_new_byteval_syntax() {
    let id = Id48::from_u64(0x112233445566);
    assert_eq!(id.value(), 0x112233445566);
    assert_eq!(std::mem::size_of::<Id48>(), 6);
    assert_eq!(std::mem::align_of::<Id48>(), 2);

    let id64 = Id64::from_u64(0xDEADBEEFCAFEBABE);
    assert_eq!(id64.value(), 0xDEADBEEFCAFEBABE);
    assert_eq!(std::mem::size_of::<Id64>(), 8);
}

#[test]
fn test_manual_alignment() {
    assert_eq!(std::mem::align_of::<AlignedId48>(), 2);
    assert_eq!(std::mem::size_of::<AlignedId48>(), 6);

    assert_eq!(std::mem::align_of::<AlignedId64>(), 8);
    assert_eq!(std::mem::size_of::<AlignedId64>(), 8);
}

#[test]
fn test_default_u8() {
    let id = Id24::from_u32(0xABCDEF);
    assert_eq!(id.value(), 0xABCDEF);
    assert_eq!(std::mem::size_of::<Id24>(), 3);
}

#[test]
fn test_signed_byteval() {
    // 24-bit signed bounds: -8,388,608 to 8,388,607
    let mut id24 = SignedId24::default();
    id24.set_value(-500);
    assert_eq!(id24.value(), -500);

    id24.set_value(8388607); // Max
    assert_eq!(id24.value(), 8388607);

    id24.set_value(-8388608); // Min
    assert_eq!(id24.value(), -8388608);

    // 48-bit signed bounds
    let mut id48 = SignedId48::default();
    id48.set_value(-999_999_999);
    assert_eq!(id48.value(), -999_999_999);
}