Trait BitWrite 

pub trait BitWrite<E: Endianness> {
    type Error: Error + Send + Sync + 'static;

    // Required methods
    fn write_bits(
        &mut self,
        value: u64,
        num_bits: usize,
    ) -> Result<usize, Self::Error>;
    fn write_unary(&mut self, n: u64) -> Result<usize, Self::Error>;
    fn flush(&mut self) -> Result<usize, Self::Error>;

    // Provided method
    fn copy_from<F: Endianness, R: BitRead<F>>(
        &mut self,
        bit_read: &mut R,
        n: u64,
    ) -> Result<(), CopyError<R::Error, Self::Error>> { ... }
}

Sequential, streaming bit-by-bit writes.

This trait specifies basic operations over which codes can be implemented by traits such as crate::codes::gamma::GammaWriteParam.

Required Associated Types

type Error: Error + Send + Sync + 'static

Required Methods

fn write_bits( &mut self, value: u64, num_bits: usize, ) -> Result<usize, Self::Error>

Writes the lowest num_bits bits of value to the stream and returns the number of bits written, that is, num_bits.

Implementors should check the value of num_bits in test mode and panic if it is greater than 64. Moreover, if the feature checks is enabled they should check that the remaining bits of value are zero.

fn write_unary(&mut self, n: u64) -> Result<usize, Self::Error>

Writes n as a unary code to the stream and returns the number of bits written, that is, n plus one.

Implementations are required to support the range [0 . . 2⁶⁴ – 1).

fn flush(&mut self) -> Result<usize, Self::Error>

Flushes the buffer, consuming the bit stream.

Returns the number of bits written from the bit buffer (not including padding).

Provided Methods

fn copy_from<F: Endianness, R: BitRead<F>>( &mut self, bit_read: &mut R, n: u64, ) -> Result<(), CopyError<R::Error, Self::Error>>

Copy bits from a BitRead stream to self.

Errors

This method can return a CopyError if the source stream returns an error while reading, or if the destination stream returns an error while writing.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<E: Endianness, BW: BitWrite<E>, const PRINT: bool> BitWrite<E> for CountBitWriter<E, BW, PRINT>

type Error = <BW as BitWrite<E>>::Error

impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W>

type Error = <W as BitWrite<E>>::Error

impl<WW: WordWrite, WP: WriteParams> BitWrite<BigEndian> for BufBitWriter<BE, WW, WP>

where u64: PrimitiveNumberAs<WW::Word>,

type Error = <WW as WordWrite>::Error

impl<WW: WordWrite, WP: WriteParams> BitWrite<LittleEndian> for BufBitWriter<LE, WW, WP>

where u64: PrimitiveNumberAs<WW::Word>,

type Error = <WW as WordWrite>::Error