Struct WriteBuf 

pub struct WriteBuf<'a> { /* private fields */ }

Implementations

impl WriteBuf<'_>

pub fn str_cb( &mut self, tag: &TLVTag, cb: impl FnOnce(&mut [u8]) -> Result<usize, Error>, ) -> Result<(), Error>

Write a tag and a TLV Octet String to the TLV stream, where the Octet String is a slice of u8 bytes.

The writing is done via a user-supplied callback cb, that is expected to fill the provided buffer with the data and to return the length of the written data.

This method is useful when the data to be written needs to be computed first, and the computation needs a buffer where to operate.

Note that this method reserves a Str16l header before invoking the callback, restricting the data length to no more than 65535 bytes. If the actual length fits in a single byte, the header is downgraded in-place to a canonical Str8l encoding (shortest-form length), which some strict Matter controllers (e.g. SmartThings) require.

pub fn utf8_cb( &mut self, tag: &TLVTag, cb: impl FnOnce(&mut [u8]) -> Result<usize, Error>, ) -> Result<(), Error>

Write a tag and a TLV UTF-8 String to the TLV stream, where the UTF-8 String is a str.

The writing is done via a user-supplied callback cb, that is expected to fill the provided buffer with the data and to return the length of the written data.

This method is useful when the data to be written needs to be computed first, and the computation needs a buffer where to operate.

Note that this method reserves a Utf16l header before invoking the callback, restricting the data length to no more than 65535 bytes. If the actual length fits in a single byte, the header is downgraded in-place to a canonical Utf8l encoding (shortest-form length).

impl<'a> WriteBuf<'a>

pub fn new(buf: &'a mut [u8]) -> WriteBuf<'a>

pub fn new_with(buf: &'a mut [u8], start: usize, end: usize) -> WriteBuf<'a>

pub fn get_start(&self) -> usize

pub fn get_tail(&self) -> usize

pub fn rewind_tail_to(&mut self, new_end: usize)

pub fn forward_tail_by(&mut self, new_offset: usize)

pub fn as_slice(&self) -> &[u8]

pub fn as_mut_slice(&mut self) -> &mut [u8]

pub fn empty_as_mut_slice(&mut self) -> &mut [u8]

pub fn split(self) -> (&'a mut [u8], WriteBuf<'a>)

pub fn split_str(self) -> (&'a str, WriteBuf<'a>)

pub fn into_buf(self) -> &'a mut [u8]

pub fn reset(&mut self)

pub fn load(&mut self, wb: &WriteBuf<'_>) -> Result<(), Error>

pub fn reserve(&mut self, reserve: usize) -> Result<(), Error>

pub fn shrink(&mut self, with: usize) -> Result<(), Error>

pub fn expand(&mut self, by: usize) -> Result<(), Error>

pub fn prepend_with<F>(&mut self, size: usize, f: F) -> Result<(), Error>

where F: FnOnce(&mut WriteBuf<'a>),

pub fn prepend(&mut self, src: &[u8]) -> Result<(), Error>

pub fn append_with_buf<F>(&mut self, f: F) -> Result<usize, Error>

where F: FnOnce(&mut [u8]) -> Result<usize, Error>,

pub fn append_with<F>(&mut self, size: usize, f: F) -> Result<(), Error>

where F: FnOnce(&mut WriteBuf<'a>),

pub fn append(&mut self, src: &[u8]) -> Result<(), Error>

pub fn copy_from_slice(&mut self, src: &[u8]) -> Result<(), Error>

pub fn le_i8(&mut self, data: i8) -> Result<(), Error>

pub fn le_u8(&mut self, data: u8) -> Result<(), Error>

pub fn le_u16(&mut self, data: u16) -> Result<(), Error>

pub fn le_i16(&mut self, data: i16) -> Result<(), Error>

pub fn le_u32(&mut self, data: u32) -> Result<(), Error>

pub fn le_i32(&mut self, data: i32) -> Result<(), Error>

pub fn le_u64(&mut self, data: u64) -> Result<(), Error>

pub fn le_i64(&mut self, data: i64) -> Result<(), Error>

Trait Implementations

impl<'a> Debug for WriteBuf<'a>

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

Formats the value using the given formatter.

impl TLVWrite for WriteBuf<'_>

type Position = usize

fn write(&mut self, byte: u8) -> Result<(), Error>

Append a single byte to the TLV stream.

fn get_tail(&self) -> <WriteBuf<'_> as TLVWrite>::Position

Get the current position in the TLV stream.

fn rewind_to(&mut self, pos: <WriteBuf<'_> as TLVWrite>::Position)

Rewind the TLV stream to a previous position.

fn available_space(&mut self) -> &mut [u8]

Get a mutable slice of the available space in the TLV stream.

fn str_cb( &mut self, tag: &TLVTag, cb: impl FnOnce(&mut [u8]) -> Result<usize, Error>, ) -> Result<(), Error>

Write a tag and a TLV Octet String to the TLV stream, where the Octet String is a slice of u8 bytes.

fn utf8_cb( &mut self, tag: &TLVTag, cb: impl FnOnce(&mut [u8]) -> Result<usize, Error>, ) -> Result<(), Error>

Write a tag and a TLV UTF-8 String to the TLV stream, where the UTF-8 String is a str.

fn write_ctx<T>(&mut self, ctx: u8, value: &T) -> Result<(), Error>

where T: ToTLV, Self: Sized,

Write value under a context tag.

fn tlv(&mut self, tag: &TLVTag, value: &TLVValue<'_>) -> Result<(), Error>

Write a TLV tag and value to the TLV stream.

fn i8(&mut self, tag: &TLVTag, data: i8) -> Result<(), Error>

Write a tag and a TLV S8 value to the TLV stream.

fn u8(&mut self, tag: &TLVTag, data: u8) -> Result<(), Error>

Write a tag and a TLV U8 value to the TLV stream.

fn i16(&mut self, tag: &TLVTag, data: i16) -> Result<(), Error>

Write a tag and a TLV S16 or (if the data is small enough) S8 value to the TLV stream.

fn u16(&mut self, tag: &TLVTag, data: u16) -> Result<(), Error>

Write a tag and a TLV U16 or (if the data is small enough) U8 value to the TLV stream.

fn i32(&mut self, tag: &TLVTag, data: i32) -> Result<(), Error>

Write a tag and a TLV S32 or (if the data is small enough) S16 or S8 value to the TLV stream.

fn u32(&mut self, tag: &TLVTag, data: u32) -> Result<(), Error>

Write a tag and a TLV U32 or (if the data is small enough) U16 or U8 value to the TLV stream.

fn i64(&mut self, tag: &TLVTag, data: i64) -> Result<(), Error>

Write a tag and a TLV S64 or (if the data is small enough) S32, S16, or S8 value to the TLV stream.

fn u64(&mut self, tag: &TLVTag, data: u64) -> Result<(), Error>

Write a tag and a TLV U64 or (if the data is small enough) U32, U16, or U8 value to the TLV stream.

fn f32(&mut self, tag: &TLVTag, data: f32) -> Result<(), Error>

Write a tag and a TLV F32 to the TLV stream.

fn f64(&mut self, tag: &TLVTag, data: f64) -> Result<(), Error>

Write a tag and a TLV F64 to the TLV stream.

fn str(&mut self, tag: &TLVTag, data: &[u8]) -> Result<(), Error>

Write a tag and a TLV Octet String to the TLV stream, where the Octet String is a slice of u8 bytes.

fn stri<I>(&mut self, tag: &TLVTag, len: usize, data: I) -> Result<(), Error>

where I: IntoIterator<Item = u8>,

Write a tag and a TLV Octet String to the TLV stream, where the Octet String is anything that can be turned into an iterator of u8 bytes.

fn utf8(&mut self, tag: &TLVTag, data: &str) -> Result<(), Error>

Write a tag and a TLV UTF-8 String to the TLV stream, where the UTF-8 String is a str.

fn utf8i<I>(&mut self, tag: &TLVTag, len: usize, data: I) -> Result<(), Error>

where I: IntoIterator<Item = u8>,

Write a tag and a TLV UTF-8 String to the TLV stream, where the UTF-8 String is anything that can be turned into an iterator of u8 bytes.

fn start_struct(&mut self, tag: &TLVTag) -> Result<(), Error>

Write a tag and a value indicating the start of a Struct TLV container.

fn start_array(&mut self, tag: &TLVTag) -> Result<(), Error>

Write a tag and a value indicating the start of an Array TLV container.

fn start_list(&mut self, tag: &TLVTag) -> Result<(), Error>

Write a tag and a value indicating the start of a List TLV container.

fn start_container( &mut self, tag: &TLVTag, container_type: TLVValueType, ) -> Result<(), Error>

Write a tag and a value indicating the start of a Struct TLV container.

fn end_container(&mut self) -> Result<(), Error>

Write a value indicating the end of a Struct, Array, or List TLV container.

fn null(&mut self, tag: &TLVTag) -> Result<(), Error>

Write a tag and a TLV Null value to the TLV stream.

fn bool(&mut self, tag: &TLVTag, val: bool) -> Result<(), Error>

Write a tag and a TLV True or False value to the TLV stream.

fn raw_value( &mut self, tag: &TLVTag, value_type: TLVValueType, value_payload: &[u8], ) -> Result<(), Error>

Write a tag and a raw, already-encoded TLV value represented as a byte slice.

fn write_raw_data<I>(&mut self, bytes: I) -> Result<(), Error>

where I: IntoIterator<Item = u8>,

Append multiple raw bytes to the TLV stream.

impl Write for WriteBuf<'_>

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.