Struct Writer 

pub struct Writer {
    pub data: Vec<u8>,
    pub wide_strings: bool,
    /* private fields */
}

The writing side of Reader (IO::BinaryWriter): little-endian values, 8-bit strings and blocks whose size is filled in when they close.

Fields

data: Vec<u8>

The bytes written.

wide_strings: bool

Write System::Strings as UTF-16 (as older builds did) instead of 8-bit.

Implementations

impl Writer

pub fn new() -> Self

An empty writer.

pub fn set_reference_ids(&mut self, ids: &BTreeMap<u32, String>)

Write external pointers as reference ids (the inverse of the reference table).

pub fn bytes(&mut self, b: &[u8])

Write bytes as they are.

pub fn u8(&mut self, v: u8)

Write a u8.

pub fn bool(&mut self, v: bool)

Write a bool as one byte.

pub fn i16(&mut self, v: i16)

Write an i16.

pub fn u16(&mut self, v: u16)

Write a u16.

pub fn u32(&mut self, v: u32)

Write a u32.

pub fn i32(&mut self, v: i32)

Write an i32.

pub fn i64(&mut self, v: i64)

Write an i64.

pub fn f32(&mut self, v: f32)

Write an f32.

pub fn count(&mut self, n: usize)

A count as the reader’s count takes it.

pub fn string(&mut self, s: &str)

System::String with the 8-bit flag (or UTF-16 with Writer::wide_strings); the length counts the NUL.

pub fn wstring(&mut self, s: &str)

A UTF-16 string: the unit count with its NUL, then the units.

pub fn external_ref(&mut self, path: Option<&str>) -> Result<()>

ExternalPtr, in reference mode an id (u32::MAX for none), else a present flag and the path.

pub fn begin_block(&mut self, version: u32) -> usize

Open a block at version; returns where its size goes, for Writer::end_block.

pub fn end_block(&mut self, size_at: usize)

Close the block opened at size_at. The size covers the payload and terminator, not the version.

pub fn block<T>( &mut self, version: u32, f: impl FnOnce(&mut Self) -> Result<T>, ) -> Result<T>

One block at version, its payload written by f.

Trait Implementations

impl Default for Writer

fn default() -> Writer

Returns the “default value” for a type.