Struct BitReader 

struct BitReader<'a> {
    bytes: &'a [u8],
    pos: u32,
}

Fields

bytes: &'a [u8]

pos: u32

Implementations

impl<'a> BitReader<'a>

fn new(bytes: &'a [u8]) -> Self

Examples found in repository

crates/competitive/src/tools/coding.rs (line 335)

fn huffman_decoding(bytes: &[u8]) -> Vec<u8> {
    fn read_tree(reader: &mut BitReader) -> HuffmanTree {
        if reader.read_bit() {
            HuffmanTree::Node(Box::new(read_tree(reader)), Box::new(read_tree(reader)))
        } else {
            HuffmanTree::Leaf(reader.read_u8())
        }
    }
    fn decode(mut t: &HuffmanTree, reader: &mut BitReader) -> u8 {
        loop {
            match t {
                HuffmanTree::Leaf(i) => break *i,
                HuffmanTree::Node(l, r) => t = if reader.read_bit() { r } else { l },
            }
        }
    }

    let mut reader = BitReader::new(bytes);
    let t = read_tree(&mut reader);
    const C: usize = size_of::<usize>();
    let mut size: [u8; C] = [0u8; C];
    for b in &mut size {
        *b = decode(&t, &mut reader);
    }
    let size = usize::from_le_bytes(size);
    let mut buf = vec![];
    for i in 0..size {
        buf.push(decode(&t, &mut reader));
        if i < 10 {}
    }
    buf
}

fn read_bit(&mut self) -> bool

Examples found in repository

crates/competitive/src/tools/coding.rs (line 320)

    fn read_tree(reader: &mut BitReader) -> HuffmanTree {
        if reader.read_bit() {
            HuffmanTree::Node(Box::new(read_tree(reader)), Box::new(read_tree(reader)))
        } else {
            HuffmanTree::Leaf(reader.read_u8())
        }
    }
    fn decode(mut t: &HuffmanTree, reader: &mut BitReader) -> u8 {
        loop {
            match t {
                HuffmanTree::Leaf(i) => break *i,
                HuffmanTree::Node(l, r) => t = if reader.read_bit() { r } else { l },
            }
        }
    }

fn read_u8(&mut self) -> u8

Examples found in repository

crates/competitive/src/tools/coding.rs (line 323)

    fn read_tree(reader: &mut BitReader) -> HuffmanTree {
        if reader.read_bit() {
            HuffmanTree::Node(Box::new(read_tree(reader)), Box::new(read_tree(reader)))
        } else {
            HuffmanTree::Leaf(reader.read_u8())
        }
    }

Trait Implementations

impl<'a> Debug for BitReader<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.