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

use crate::read::Read;
use crate::word::*;
use crate::write::Write;
use crate::Result;

/// A buffer that can only hold 64 bits, but only uses registers instead of load/store.
#[derive(Default)]
pub struct RegisterBuffer {
    value: Word,
    index: usize,
}

impl RegisterBuffer {
    /// Writes the contents of the buffer to `writer` and clears the buffer.
    pub fn flush(&mut self, writer: &mut impl Write) {
        debug_assert!(self.index <= 64, "too many bits written to RegisterBuffer");
        writer.write_bits(self.value, self.index);
        *self = Self::default();
    }

    /// Advances by the amount read from the buffer and refills the buffer.
    pub fn refill(&mut self, reader: &mut impl Read) -> Result<()> {
        self.advance_reader(reader)?;
        self.value = reader.peek_bits()?;
        self.index = 0;
        Ok(())
    }

    /// Only advances the reader. Doesn't refill the buffer.
    pub fn advance_reader(&mut self, reader: &mut impl Read) -> Result<()> {
        debug_assert!(self.index <= 64, "too many bits read from RegisterBuffer");
        reader.advance(self.index)?;
        *self = Self::default();
        Ok(())
    }
}

impl Write for RegisterBuffer {
    fn start_write(&mut self) {
        unimplemented!()
    }

    fn finish_write(&mut self) -> &[u8] {
        unimplemented!()
    }

    fn write_bit(&mut self, v: bool) {
        self.write_bits(v as Word, 1);
    }

    fn write_bits(&mut self, word: Word, bits: usize) {
        self.value |= word << self.index;
        self.index += bits;
    }

    fn write_bytes(&mut self, _: &[u8]) {
        unimplemented!()
    }
}

impl Read for RegisterBuffer {
    fn start_read(&mut self, _: &[u8]) {
        unimplemented!()
    }

    fn finish_read(&self) -> Result<()> {
        unimplemented!()
    }

    fn advance(&mut self, bits: usize) -> Result<()> {
        self.index += bits;
        Ok(())
    }

    fn peek_bits(&mut self) -> Result<Word> {
        Ok(self.value)
    }

    fn read_bit(&mut self) -> Result<bool> {
        Ok(self.read_bits(1)? != 0)
    }

    fn read_bits(&mut self, bits: usize) -> Result<Word> {
        debug_assert!(self.index < 64);
        let v = (self.value >> self.index) & (Word::MAX >> (WORD_BITS - bits));

        self.advance(bits)?;
        Ok(v)
    }

    fn read_bytes(&mut self, _: usize) -> Result<&[u8]> {
        unimplemented!()
    }

    fn reserve_bits(&self, _: usize) -> Result<()> {
        Ok(())
    }
}