Struct bitstream_io::write::BitCounter

pub struct BitCounter<N, E: Endianness> { /* fields omitted */ }

For counting the number of bits written but generating no output.

Example

use bitstream_io::{BigEndian, BitWrite, BitCounter};
let mut writer: BitCounter<u32, BigEndian> = BitCounter::new();
writer.write(1, 0b1).unwrap();
writer.write(2, 0b01).unwrap();
writer.write(5, 0b10111).unwrap();
assert_eq!(writer.written(), 8);

Implementations

impl<N: Default + Copy, E: Endianness> BitCounter<N, E>

pub fn new() -> Self

Creates new counter

pub fn written(&self) -> N

Returns number of bits written

Trait Implementations

impl<N, E> BitWrite for BitCounter<N, E> where
    E: Endianness,
    N: Copy + AddAssign + From<u32> + Rem<Output = N> + PartialEq, 

pub fn write_bit(&mut self, _bit: bool) -> Result<()>

Writes a single bit to the stream. true indicates 1, false indicates 0

pub fn write<U>(&mut self, bits: u32, value: U) -> Result<()> where
    U: Numeric, 

Writes an unsigned value to the stream using the given number of bits.

pub fn write_signed<S>(&mut self, bits: u32, value: S) -> Result<()> where
    S: SignedNumeric, 

Writes a twos-complement signed value to the stream with the given number of bits.

pub fn write_unary1(&mut self, value: u32) -> Result<()>

Writes value number of 0 bits to the stream and then writes a 1 bit. This field is variably-sized.

pub fn write_unary0(&mut self, value: u32) -> Result<()>

Writes value number of 1 bits to the stream and then writes a 0 bit. This field is variably-sized.

pub fn write_bytes(&mut self, buf: &[u8]) -> Result<()>

Writes the entirety of a byte buffer to the stream.

pub fn byte_aligned(&self) -> bool

Returns true if the stream is aligned at a whole byte.

pub fn byte_align(&mut self) -> Result<()>

Pads the stream with 0 bits until it is aligned at a whole byte. Does nothing if the stream is already aligned.

impl<N: Default, E: Default + Endianness> Default for BitCounter<N, E>

pub fn default() -> BitCounter<N, E>

Returns the "default value" for a type.

impl<N, E> HuffmanWrite<E> for BitCounter<N, E> where
    E: Endianness,
    N: AddAssign + From<u32>, 

pub fn write_huffman<T>(
    &mut self,
    tree: &WriteHuffmanTree<E, T>,
    symbol: T
) -> Result<()> where
    T: Ord + Copy, 

Writes Huffman code for the given symbol to the stream.