Struct bitstream_io::write::BitWriter
[−]
[src]
pub struct BitWriter<'a, E: Endianness> { /* fields omitted */ }
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.
Methods
impl<'a, E: Endianness> BitWriter<'a, E>
[src]
fn new(writer: &mut Write) -> BitWriter<E>
Wraps a BitWriter around something that implements Write
fn write_bit(&mut self, bit: bool) -> Result<(), Error>
Writes a single bit to the stream.
true
indicates 1, false
indicates 0
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); 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!(data, [0b10110111]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<LittleEndian>::new(&mut data); 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!(data, [0b10110111]);
fn write<U>(&mut self, bits: u32, value: U) -> Result<(), Error> where
U: Numeric,
U: Numeric,
Writes an unsigned value to the stream using the given number of bits. Returns an error if the input type is too small to hold the requested number of bits or if the value is too large to fit those bits.
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write(1, 0b1).unwrap(); writer.write(2, 0b01).unwrap(); writer.write(5, 0b10111).unwrap(); } assert_eq!(data, [0b10110111]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<LittleEndian>::new(&mut data); writer.write(1, 0b1).unwrap(); writer.write(2, 0b11).unwrap(); writer.write(5, 0b10110).unwrap(); } assert_eq!(data, [0b10110111]);
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); let mut w = BitWriter::<BigEndian>::new(&mut data); 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 3 bits
fn write_bytes(&mut self, buf: &[u8]) -> Result<(), Error>
Writes the entirety of a byte buffer to the stream.
If the stream is already byte-aligned, it will often
map to a faster write_all
call. Otherwise it will
write bytes individually in 8-bit increments.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write(8, 0x66).unwrap(); writer.write(8, 0x6F).unwrap(); writer.write(8, 0x6F).unwrap(); writer.write_bytes(b"bar").unwrap(); } assert_eq!(data, b"foobar");
fn write_huffman<T>(
&mut self,
tree: &WriteHuffmanTree<E, T>,
symbol: T
) -> Result<(), Error> where
T: Ord + Copy,
&mut self,
tree: &WriteHuffmanTree<E, T>,
symbol: T
) -> Result<(), Error> where
T: Ord + Copy,
Writes Huffman code for the given symbol to the stream.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; 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 data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write_huffman(&tree, 'b').unwrap(); writer.write_huffman(&tree, 'c').unwrap(); writer.write_huffman(&tree, 'd').unwrap(); } assert_eq!(data, [0b10110111]);
fn write_unary0(&mut self, value: u32) -> Result<(), Error>
Writes value
number of 1 bits to the stream
and then writes a 0 bit. This field is variably-sized.
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write_unary0(0).unwrap(); writer.write_unary0(3).unwrap(); writer.write_unary0(10).unwrap(); } assert_eq!(data, [0b01110111, 0b11111110]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<LittleEndian>::new(&mut data); writer.write_unary0(0).unwrap(); writer.write_unary0(3).unwrap(); writer.write_unary0(10).unwrap(); } assert_eq!(data, [0b11101110, 0b01111111]);
fn write_unary1(&mut self, value: u32) -> Result<(), Error>
Writes value
number of 0 bits to the stream
and then writes a 1 bit. This field is variably-sized.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write_unary1(0).unwrap(); writer.write_unary1(3).unwrap(); writer.write_unary1(10).unwrap(); } assert_eq!(data, [0b10001000, 0b00000001]);
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<LittleEndian>::new(&mut data); writer.write_unary1(0).unwrap(); writer.write_unary1(3).unwrap(); writer.write_unary1(10).unwrap(); } assert_eq!(data, [0b00010001, 0b10000000]);
fn byte_aligned(&self) -> bool
Returns true if the stream is aligned at a whole byte.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); let mut writer = BitWriter::<BigEndian>::new(&mut data); 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);
fn byte_align(&mut self) -> Result<(), Error>
Pads the stream with 0 bits until it is aligned at a whole byte. Does nothing if the stream is already aligned.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write(1, 0).unwrap(); writer.byte_align().unwrap(); writer.write(8, 0xFF).unwrap(); } assert_eq!(data, [0x00, 0xFF]);
fn into_unwritten(self) -> (u32, u8)
Consumes writer and returns any un-written partial byte
as a (bits, value)
tuple.
Examples
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); let (bits, value) = { let mut writer = BitWriter::<BigEndian>::new(&mut data); 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}; let mut data = Vec::new(); let (bits, value) = { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write(8, 0b1010_0101).unwrap(); writer.into_unwritten() }; assert_eq!(data, [0b1010_0101]); assert_eq!(bits, 0); assert_eq!(value, 0);
impl<'a> BitWriter<'a, BigEndian>
[src]
fn write_signed<S>(&mut self, bits: u32, value: S) -> Result<(), Error> where
S: SignedNumeric,
S: SignedNumeric,
Writes a twos-complement signed value to the stream with the given number of bits. Returns an error if the input type is too small to hold the requested number of bits.
Example
use std::io::Write; use bitstream_io::{BigEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<BigEndian>::new(&mut data); writer.write_signed(4, -5).unwrap(); writer.write_signed(4, 7).unwrap(); } assert_eq!(data, [0b10110111]);
impl<'a> BitWriter<'a, LittleEndian>
[src]
fn write_signed<S>(&mut self, bits: u32, value: S) -> Result<(), Error> where
S: SignedNumeric,
S: SignedNumeric,
Writes a twos-complement signed value to the stream with the given number of bits. Returns an error if the input type is too small to hold the requested number of bits.
Example
use std::io::Write; use bitstream_io::{LittleEndian, BitWriter}; let mut data = Vec::new(); { let mut writer = BitWriter::<LittleEndian>::new(&mut data); writer.write_signed(4, 7).unwrap(); writer.write_signed(4, -5).unwrap(); } assert_eq!(data, [0b10110111]);