[−][src]Trait bitstream_io::write::BitWrite

pub trait BitWrite {
    pub fn write_bit(&mut self, bit: bool) -> Result<()>;

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

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

    pub fn byte_aligned(&self) -> bool;

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

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

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

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

A trait for anything that can write a variable number of potentially un-aligned values to an output stream

Required methods

pub fn write_bit(&mut self, bit: bool) -> Result<()>[src]

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

Errors

Passes along any I/O error from the underlying stream.

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

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

Errors

Passes along any I/O error from the underlying stream. Returns an error if the input type is too small to hold the given number of bits. Returns an error if the value is too large to fit the given number of bits.

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

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

Errors

Passes along any I/O error from the underlying stream. Returns an error if the input type is too small to hold the given number of bits. Returns an error if the value is too large to fit the given number of bits.

pub fn byte_aligned(&self) -> bool[src]

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

Loading content...

Provided methods

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

Writes the entirety of a byte buffer to the stream.

Errors

Passes along any I/O error from the underlying stream.

Example

use std::io::Write;
use bitstream_io::{BigEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), BigEndian);
writer.write(8, 0x66).unwrap();
writer.write(8, 0x6F).unwrap();
writer.write(8, 0x6F).unwrap();
writer.write_bytes(b"bar").unwrap();
assert_eq!(writer.into_writer(), b"foobar");

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

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

Errors

Passes along any I/O error from the underyling stream.

Examples

use std::io::Write;
use bitstream_io::{BigEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), BigEndian);
writer.write_unary0(0).unwrap();
writer.write_unary0(3).unwrap();
writer.write_unary0(10).unwrap();
assert_eq!(writer.into_writer(), [0b01110111, 0b11111110]);
use std::io::Write;
use bitstream_io::{LittleEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), LittleEndian);
writer.write_unary0(0).unwrap();
writer.write_unary0(3).unwrap();
writer.write_unary0(10).unwrap();
assert_eq!(writer.into_writer(), [0b11101110, 0b01111111]);

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

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

Errors

Passes along any I/O error from the underyling stream.

Example

use std::io::Write;
use bitstream_io::{BigEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), BigEndian);
writer.write_unary1(0).unwrap();
writer.write_unary1(3).unwrap();
writer.write_unary1(10).unwrap();
assert_eq!(writer.into_writer(), [0b10001000, 0b00000001]);
use std::io::Write;
use bitstream_io::{LittleEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), LittleEndian);
writer.write_unary1(0).unwrap();
writer.write_unary1(3).unwrap();
writer.write_unary1(10).unwrap();
assert_eq!(writer.into_writer(), [0b00010001, 0b10000000]);

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

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

Errors

Passes along any I/O error from the underyling stream.

Example

use std::io::Write;
use bitstream_io::{BigEndian, BitWriter, BitWrite};
let mut writer = BitWriter::endian(Vec::new(), BigEndian);
writer.write(1, 0).unwrap();
writer.byte_align().unwrap();
writer.write(8, 0xFF).unwrap();
assert_eq!(writer.into_writer(), [0x00, 0xFF]);
Loading content...

Implementors

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

impl<N, E> BitWrite for BitRecorder<N, E> where
    E: Endianness,
    N: Copy + From<u32> + AddAssign + Rem<Output = N> + Eq, [src]

impl<W: Write, E: Endianness> BitWrite for BitWriter<W, E>[src]

pub fn write_bit(&mut self, bit: bool) -> Result<()>[src]

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]);

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

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

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

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]);

pub fn byte_aligned(&self) -> bool[src]

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);
Loading content...