Struct bitstream_io::write::BitWriter [−][src]
pub struct BitWriter<W: Write, E: Endianness> { /* fields omitted */ }
Expand description
For writing bit values to an underlying stream in a given endianness.
Because this only writes whole bytes to the underlying stream, it is important that output is byte-aligned before the bitstream writer’s lifetime ends. Partial bytes will be lost if the writer is disposed of before they can be written.
Implementations
Wraps a BitWriter around something that implements Write
Wraps a BitWriter around something that implements Write
with the given endianness.
Unwraps internal writer and disposes of BitWriter.
Warning
Any unwritten partial bits are discarded.
If stream is byte-aligned, provides mutable reference
to internal writer. Otherwise returns None
Converts BitWriter
to ByteWriter
in the same endianness.
Warning
Any written partial bits are discarded.
If stream is byte-aligned, provides temporary ByteWriter
in the same endianness. Otherwise returns None
Warning
Any unwritten bits left over when ByteWriter
is dropped are lost.
Consumes writer and returns any un-written partial byte
as a (bits, value)
tuple.
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut data = Vec::new(); let (bits, value) = { let mut writer = BitWriter::endian(&mut data, BigEndian); writer.write(15, 0b1010_0101_0101_101).unwrap(); writer.into_unwritten() }; assert_eq!(data, [0b1010_0101]); assert_eq!(bits, 7); assert_eq!(value, 0b0101_101);
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut data = Vec::new(); let (bits, value) = { let mut writer = BitWriter::endian(&mut data, BigEndian); writer.write(8, 0b1010_0101).unwrap(); writer.into_unwritten() }; assert_eq!(data, [0b1010_0101]); assert_eq!(bits, 0); assert_eq!(value, 0);
Trait Implementations
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), BigEndian); writer.write_bit(true).unwrap(); writer.write_bit(false).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(false).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), LittleEndian); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(false).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(true).unwrap(); writer.write_bit(false).unwrap(); writer.write_bit(true).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), BigEndian); writer.write(1, 0b1).unwrap(); writer.write(2, 0b01).unwrap(); writer.write(5, 0b10111).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), LittleEndian); writer.write(1, 0b1).unwrap(); writer.write(2, 0b11).unwrap(); writer.write(5, 0b10110).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
use std::io::{Write, sink}; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut w = BitWriter::endian(sink(), BigEndian); assert!(w.write(9, 0u8).is_err()); // can't write u8 in 9 bits assert!(w.write(17, 0u16).is_err()); // can't write u16 in 17 bits assert!(w.write(33, 0u32).is_err()); // can't write u32 in 33 bits assert!(w.write(65, 0u64).is_err()); // can't write u64 in 65 bits assert!(w.write(1, 2).is_err()); // can't write 2 in 1 bit assert!(w.write(2, 4).is_err()); // can't write 4 in 2 bits assert!(w.write(3, 8).is_err()); // can't write 8 in 3 bits assert!(w.write(4, 16).is_err()); // can't write 16 in 4 bits
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), BigEndian); writer.write_signed(4, -5).unwrap(); writer.write_signed(4, 7).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(Vec::new(), LittleEndian); writer.write_signed(4, 7).unwrap(); writer.write_signed(4, -5).unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
Example
use std::io::{Write, sink}; use bitstream_io::{BigEndian, BitWriter, BitWrite}; let mut writer = BitWriter::endian(sink(), BigEndian); assert_eq!(writer.byte_aligned(), true); writer.write(1, 0).unwrap(); assert_eq!(writer.byte_aligned(), false); writer.write(7, 0).unwrap(); assert_eq!(writer.byte_aligned(), true);
Writes the entirety of a byte buffer to the stream. Read more
Writes value
number of 1 bits to the stream
and then writes a 0 bit. This field is variably-sized. Read more
Writes value
number of 0 bits to the stream
and then writes a 1 bit. This field is variably-sized. Read more
Pads the stream with 0 bits until it is aligned at a whole byte. Does nothing if the stream is already aligned. Read more
fn write_huffman<T>(
&mut self,
tree: &WriteHuffmanTree<E, T>,
symbol: T
) -> Result<()> where
T: Ord + Copy,
[src]
fn write_huffman<T>(
&mut self,
tree: &WriteHuffmanTree<E, T>,
symbol: T
) -> Result<()> where
T: Ord + Copy,
[src]Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter, HuffmanWrite}; use bitstream_io::huffman::compile_write_tree; let tree = compile_write_tree( vec![('a', vec![0]), ('b', vec![1, 0]), ('c', vec![1, 1, 0]), ('d', vec![1, 1, 1])]).unwrap(); let mut writer = BitWriter::endian(Vec::new(), BigEndian); writer.write_huffman(&tree, 'b').unwrap(); writer.write_huffman(&tree, 'c').unwrap(); writer.write_huffman(&tree, 'd').unwrap(); assert_eq!(writer.into_writer(), [0b10110111]);
Auto Trait Implementations
impl<W, E> RefUnwindSafe for BitWriter<W, E> where
E: RefUnwindSafe,
W: RefUnwindSafe,
impl<W, E> UnwindSafe for BitWriter<W, E> where
E: UnwindSafe,
W: UnwindSafe,