Struct ByteWriter

pub struct ByteWriter<W: Write, E: Endianness> { /* private fields */ }

For writing aligned bytes to a stream of bytes in a given endianness.

This only writes aligned values and maintains no internal state.

Implementations

impl<W: Write, E: Endianness> ByteWriter<W, E>

pub fn new(writer: W) -> ByteWriter<W, E>

Wraps a ByteWriter around something that implements Write

Examples found in repository

examples/flac-metadata-write.rs (line 140)

fn main() {
    let mut flac: Vec<u8> = Vec::new();

    let mut writer = BitWriter::endian(&mut flac, BigEndian);

    // stream marker
    writer.write_bytes(b"fLaC").unwrap();

    // metadata block header
    writer
        .build(&BlockHeader {
            last_block: false,
            block_type: 0,
            block_size: 34,
        })
        .unwrap();

    // STREAMINFO block
    writer
        .build(&Streaminfo {
            minimum_block_size: 4096,
            maximum_block_size: 4096,
            minimum_frame_size: 1542,
            maximum_frame_size: 8546,
            sample_rate: 44100,
            channels: NonZero::new(2).unwrap(),
            bits_per_sample: NonZero::new(16).unwrap(),
            total_samples: 304844,
            md5: *b"\xFA\xF2\x69\x2F\xFD\xEC\x2D\x5B\x30\x01\x76\xB4\x62\x88\x7D\x92",
        })
        .unwrap();

    let comment = VorbisComment {
        vendor: "reference libFLAC 1.1.4 20070213".to_string(),
        comment: vec![
            "title=2ch 44100  16bit".to_string(),
            "album=Test Album".to_string(),
            "artist=Assorted".to_string(),
            "tracknumber=1".to_string(),
        ],
    };

    // metadata block header
    writer
        .build(&BlockHeader {
            last_block: false,
            block_type: 4,
            block_size: comment.len().try_into().unwrap(),
        })
        .unwrap();

    // VORBIS_COMMENT block (little endian)
    comment
        .write(&mut ByteWriter::new(writer.writer().unwrap()))
        .unwrap();

    assert_eq!(flac, include_bytes!("data/metadata-only.flac"));
}

pub fn endian(writer: W, _endian: E) -> ByteWriter<W, E>

Wraps a BitWriter around something that implements Write with the given endianness.

pub fn into_writer(self) -> W

Unwraps internal writer and disposes of ByteWriter. Any unwritten partial bits are discarded.

pub fn writer(&mut self) -> &mut W

Provides mutable reference to internal writer.

pub fn into_bitwriter(self) -> BitWriter<W, E>

Converts ByteWriter to BitWriter in the same endianness.

pub fn bitwriter(&mut self) -> BitWriter<&mut W, E>

Provides temporary BitWriter in the same endianness.

Warning

Any unwritten bits left over when BitWriter is dropped are lost.

Trait Implementations

impl<W: Write, E: Endianness> ByteWrite for ByteWriter<W, E>

fn write<V>(&mut self, value: V) -> Result<()>

where V: Primitive,

Writes whole numeric value to stream

fn write_as<F, V>(&mut self, value: V) -> Result<()>

where F: Endianness, V: Primitive,

Writes whole numeric value to stream in a potentially different endianness

fn pad(&mut self, bytes: u32) -> Result<()>

Pads the stream by writing 0 over the given number of bytes.

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

Writes the entirety of a byte buffer to the stream.

fn writer_ref(&mut self) -> &mut dyn Write

Returns mutable reference to underlying writer

fn build<T: ToByteStream>(&mut self, build: &T) -> Result<(), T::Error>

Builds and writes complex type

fn build_with<'a, T: ToByteStreamWith<'a>>( &mut self, build: &T, context: &T::Context, ) -> Result<(), T::Error>

Builds and writes complex type with context