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

use bitcram::{Packable, packable};

#[derive(Debug, PartialEq, Eq)]
struct Coord {
    x: u8,
    y: u8,
}

impl Packable<u16> for Coord {
    const SIZE: u32 = 5;
    fn pack(&self) -> u16 {
        (self.y * 5 + self.x) as u16
    }
    fn unpack(buffer: u16) -> Self {
        let i = buffer as u8;
        Self { x: i % 5, y: i / 5 }
    }
}

#[packable(u16)]
#[derive(Debug, PartialEq, Eq)]
enum Piece {
    King,
    Queen,
    Rook,
    Bishop,
    Knight,
    Pawn,
}

#[packable(u16)]
#[derive(Debug, PartialEq, Eq)]
enum Promotion {
    None,
    Queen,
    Rook,
    Bishop,
    Knight,
}

#[packable(u16)]
#[derive(Debug, PartialEq, Eq)]
struct Move {
    from: Coord,
    to: Coord,
    piece: Piece,
    promotion: Promotion,
}

fn main() {
    let m = Move {
        from: Coord { x: 0, y: 1 },
        to: Coord { x: 0, y: 3 },
        piece: Piece::Pawn,
        promotion: Promotion::None,
    };
    let packed: u16 = m.pack();
    assert_eq!(Move::unpack(packed), m);
    println!(
        "Move encodes to {} bits, packed value: {:#018b}",
        Move::SIZE,
        packed
    );
    println!("Round-trip OK");
}