Struct variable_size_byte_writer::VariableSizeByteWriter

pub struct VariableSizeByteWriter { /* fields omitted */ }

VariableSizeByteWriter provides functions for writing variable-size bytes into io::Write traited targets.

Writes are internally buffered and so the usage of any additional buffering such as std::io::BufWriter is not recommended.

Note that VariableSizeByteWriter does not flush its internal buffer when dropped.

Examples

Writing some unconventionally sized bytes into Vec<u8>

use variable_size_byte_writer::*;

let mut target = Vec::new();
let mut writer = VariableSizeByteWriter::new();
let bytes = [(0x3F, 6),(0x1AFF, 13),(0x7, 3)];

bytes
    .iter()
    .for_each(|&(byte, bits)|
        writer.write(&mut target, byte, bits).unwrap()
    );

let mut padding = 0;
writer
    .flush_all_bytes(&mut target, &mut padding)
    .unwrap();

assert_eq!(padding, 2);
assert_eq!(target[..], [0xFF, 0xBF, 0x3E]);

Writing a series of 7bit bytes into a file

use std::fs::File;
use variable_size_byte_writer::*;

let mut writer = VariableSizeByteWriter::new();
let mut file = File::create("path").unwrap();

for variable in 0..0x8F {
    writer.write(&mut file, variable, 7).unwrap();
}

let mut padding = 0;
writer
    .flush_all_bytes(&mut file, &mut padding)
    .unwrap();

Methods

impl VariableSizeByteWriter

fn new() -> Self

Creates a new instance of VariableSizeByteWriter with a default internal buffer size.

Examples

use variable_size_byte_writer::*;

let writer = VariableSizeByteWriter::new();

fn with_specified_capacity(cap: usize) -> Self

Creates a new instance of VariableSizeByteWriter with a specific internal buffer size.

Examples

use variable_size_byte_writer::*;

let writer = VariableSizeByteWriter::with_specified_capacity(4096);

fn write<T>(&mut self, writer: &mut T, variable: u64, bits: u32) -> Result<()> where
    T: Write, 

Flushes the remaining internal buffer to the given target.

The function might fail, successfully flushing none or some of the internal buffer. If the flush fails, the internal buffer remains intact and contains the content that failed to flush.

The padding required to fill the last partial byte can be captured into the argument padding. The padding is only valid if the function return without an error.

Examples

use std::fs::File;
use variable_size_byte_writer::*;

let mut writer = VariableSizeByteWriter::new();
let mut file = File::create("path")?;

writer.write(&mut file, 0x71CFFABFF, 35)?;
writer.write(&mut file, 0xFFA, 16)?;
writer.write(&mut file, 0xF1CFFABCD, 39)?;

let mut padding = 0;
writer.flush_all_bytes(&mut file, &mut padding)?;

fn flush_all_bytes<T>(
    &mut self,
    writer: &mut T,
    padding: &mut u32
) -> Result<()> where
    T: Write,