Struct Writer 

pub struct Writer { /* private fields */ }

Writes the binary form piece by piece, from data that isn’t a Value — nothing is built or copied on the way. A map or list is given its length, then that many entries (key then a value) or values.

let mut w = substrate_data::binary::Writer::new();
w.map(2).key("id").str("docs/intro").key("count").int(3);
let v = substrate_data::binary::decode(&w.finish()).unwrap();
assert_eq!(v.get("count").and_then(|c| c.as_i64()), Some(3));

Implementations

impl Writer

pub fn new() -> Self

A writer of a whole document: the header first.

pub fn null(&mut self) -> &mut Self

Null.

pub fn bool(&mut self, b: bool) -> &mut Self

A bool.

pub fn int(&mut self, n: i64) -> &mut Self

An integer: one byte for -16 to 111, else a tag and a varint.

pub fn float(&mut self, f: f64) -> &mut Self

A float: four bytes when it is an f32 exactly (layout::narrows, what a reader gives back bit for bit), else eight.

pub fn float32(&mut self, f: f32) -> &mut Self

A 32-bit float: half the bytes of Writer::float.

pub fn str(&mut self, s: &str) -> &mut Self

A string: its bytes the first time, its index after (in the tag itself for the first 32 strings of the document).

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

Bytes as they are.

pub fn list(&mut self, len: usize) -> &mut Self

A list of len values.

pub fn map(&mut self, len: usize) -> &mut Self

A map of len entries, each a Writer::key and a value: its keys written one by one, and again in every map that has them. Writer::record writes a map’s keys once for all maps with them.

pub fn key(&mut self, k: &str) -> &mut Self

A map’s key.

pub fn finish(self) -> Vec<u8>

The bytes.

impl Writer

pub fn floats(&mut self, items: &[f64]) -> &mut Self

A list of floats, packed, no tag each: four bytes each when every one is an f32 exactly (tag::FLOATS32), else eight.

pub fn floats32(&mut self, items: &[f32]) -> &mut Self

A list of 32-bit floats, packed: four bytes each, no tag.

pub fn ints(&mut self, items: impl ExactSizeIterator<Item = i64>) -> &mut Self

A list of ints, packed (no tag each).

impl Writer

pub fn record(&mut self, keys: &[&str]) -> &mut Self

A map of these keys (none repeated): the keys are written the first time this set is met and named by number after that. A value for each key follows, in order, with no Writer::key.

pub fn record_masked( &mut self, keys: &'static [&'static str], present: u64, ) -> &mut Self

A map of the keys of keys that present has a bit for (bit i for key i, at most 64 keys): what Writer::record is, for a struct whose keys are always the same slice, found again by where it is instead of by looking at its keys. A value for each key present follows, in order.

impl Writer

pub fn value(&mut self, v: &Value) -> &mut Self

A whole value. A list of ints or of floats is packed, a list of maps with one set of keys writes the keys once, a map’s keys are a shape, a small int takes a byte.

Trait Implementations

impl Debug for Writer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Writer

fn default() -> Self

Returns the “default value” for a type.