Struct async_coap::message::BufferMessageEncoder

pub struct BufferMessageEncoder<'buf> { /* fields omitted */ }

A class for writing stand-alone messages to a mutable byte slice.

Methods

impl<'buf> BufferMessageEncoder<'buf>

pub const MIN_MESSAGE_BUFFER_LEN: usize

The minimum size buffer that can be passed into new.

Important traits for BufferMessageEncoder<'a>

impl<'a> Write for BufferMessageEncoder<'a>

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

Creates a new BufferMessageEncoder using the given buffer.

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

Returns a byte slice containing the encoded message.

pub fn msg_token(&self) -> MsgToken

Returns the token set for this message.

Trait Implementations

impl<'buf> MessageWrite for BufferMessageEncoder<'buf>

fn set_msg_type(&mut self, tt: MsgType)

Sets the CoAP message type. This may be called at any time during message writing without disrupting the operation. It may be called multiple times if necessary. The written value is that of the last call.

fn set_msg_id(&mut self, msg_id: u16)

Sets the CoAP message id. This may be called at any time during message writing without disrupting the operation. It may be called multiple times if necessary. The written value is that of the last call.

fn set_msg_code(&mut self, code: MsgCode)

Sets the CoAP message code. This may be called at any time during message writing without disrupting the operation. It may be called multiple times if necessary. The written value is that of the last call.

fn set_msg_token(&mut self, token: MsgToken)

Sets the CoAP message token. Calling this method out-of-order will cause any previously written options or payload to be lost. It may be called multiple times if necessary. The written value is that of the last call.

fn append_payload_bytes(&mut self, body: &[u8]) -> Result<(), Error>

Appends bytes from the given slice body to the payload of the message. This method should only be called after the token and all options have been set. This method may be called multiple times, each time appending data to the payload.

fn clear(&mut self)

Removes the message payload along with all options.

fn append_payload_string(&mut self, body: &str) -> Result<(), Error>

Appends bytes from the UTF8 representation of the given string slice body to the payload of the message. This method should only be called after the token and all options have been set. This method may be called multiple times, each time appending data to the payload.

fn append_payload_u8(&mut self, b: u8) -> Result<(), Error>

Appends a single byte to the payload of the message. This method should only be called after the token and all options have been set. This method may be called multiple times, each time appending data to the payload.

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

Appends the UTF8 representation for a single unicode character to the payload of the message. This method should only be called after the token and all options have been set. This method may be called multiple times, each time appending data to the payload.

impl<'buf> OptionInsert for BufferMessageEncoder<'buf>

fn insert_option_with_bytes(
    &mut self,
    key: OptionNumber,
    value: &[u8]
) -> Result<(), Error>

Inserts an option into the message with the given bytes as the value. Calling this method with out-of-order keys will incur a significant performance penalty.

fn insert_option_empty(&mut self, key: OptionNumber) -> Result<(), Error>

Inserts an option into the message with no value. Calling this method with out-of-order keys will incur a significant performance penalty.

fn insert_option_with_str(
    &mut self,
    key: OptionNumber,
    value: &str
) -> Result<(), Error>

Inserts an option into the message with a string value. Calling this method with out-of-order keys will incur a significant performance penalty.

fn insert_option_with_u32(
    &mut self,
    key: OptionNumber,
    value: u32
) -> Result<(), Error>

Inserts an option into the message with an integer value. Calling this method with out-of-order keys will incur a significant performance penalty.

impl<'buf> Deref for BufferMessageEncoder<'buf>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'buf> Display for BufferMessageEncoder<'buf>

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

Formats the value using the given formatter.

impl<'buf> Debug for BufferMessageEncoder<'buf>

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

Formats the value using the given formatter.

impl<'a> Write for BufferMessageEncoder<'a>

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.