Struct Encoder 

pub struct Encoder<W: Write> { /* private fields */ }

Implementations

impl<W: Write> Encoder<W>

pub fn new(w: W) -> Self

Create an encoder.

pub fn write_null(&mut self) -> Result<Offset>

pub fn write_bool(&mut self, b: bool) -> Result<Offset>

pub fn write_i64(&mut self, n: i64) -> Result<Offset>

Write an integer.

pub fn write_ref(&mut self, p: Offset) -> Result<Offset>

pub fn write_pointer(&mut self, p: Offset) -> Result<Offset>

pub fn write_f32(&mut self, f: f32) -> Result<Offset>

pub fn write_f64(&mut self, f: f64) -> Result<Offset>

pub fn write_string(&mut self, s: &str) -> Result<Offset>

Write a unicode string.

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

Write a binary blob.

pub fn write_variant0(&mut self, c: VariantIdx) -> Result<Offset>

Write a nullary variant.

pub fn write_immediate(&mut self, imm: Immediate<'_>) -> Result<Offset>

Write an immediate value.

pub fn write_immediate_or_return_pointer( &mut self, imm: Immediate<'_>, ) -> Result<Offset>

Write the immediate; but if it’s a pointer, return the pointer without writing a thing.

pub fn write_tag(&mut self, tag: Tag, v: Immediate<'_>) -> Result<Offset>

pub fn write_array(&mut self, arr: &[Immediate<'_>]) -> Result<Offset>

Write an array.

The values in the array must be converted to immediates already, possibly by way of writing them first and making pointers to their written representation.

pub fn write_map( &mut self, map: &[(Immediate<'_>, Immediate<'_>)], ) -> Result<Offset>

Write a map. Keys and values must already be encoded into immediates.

pub fn write_variant( &mut self, c: VariantIdx, args: &[Immediate<'_>], ) -> Result<Immediate<'static>>

Write a variant c with arguments args.

pub fn finalize(self, entrypoint: Immediate<'_>) -> Result<()>

Write the postfix to point to entrypoint, and consume the encoder.