Struct Message 

pub struct Message { /* private fields */ }

A multi-part message, comprising a message body and a list of parts. Messages only contain references to underlying byte buffers and are cheaply cloned.

Implementations

impl Message

pub fn from_body_and_parts(body: Part, parts: Vec<Part>) -> Self

Returns a new message with the given body and parts.

pub fn body(&self) -> &Part

The body of the message.

pub fn parts(&self) -> &[Part]

The list of parts of the message.

pub fn num_parts(&self) -> usize

Returns the total number of parts (excluding the body) in the message.

pub fn len(&self) -> usize

Returns the total size (in bytes) of the message.

pub fn is_empty(&self) -> bool

Returns whether the message is empty. It is always false, since the body is always defined.

pub fn into_inner(self) -> (Part, Vec<Part>)

Convert this message into its constituent components.

pub fn visit_parts_mut<T, E>( &mut self, f: impl FnMut(&mut T) -> Result<(), E>, ) -> Result<(), E>

where T: Serialize + DeserializeOwned + Named, E: From<Error>,

Visit every typed part containing a T-typed value.

pub fn frame_len(&self) -> usize

Returns the total size (in bytes) of the message when it is framed.

pub fn framed(self) -> Frame

Efficiently frames a message containing the body and all of its parts using a simple frame-length encoding:

+--------------------+-------------------+--------------------+-------------------+   ...   +
| body_tag (u64 BE)  |   body bytes      | part1_tag (u64 BE) |   part1 bytes     |         |
+--------------------+-------------------+--------------------+-------------------+         +
                                                                                     repeat
                                                                                       for
                                                                                     each part

The high bit of each tag indicates whether the part is typed. If set, the lower 63 bits hold the part length, and the tag is followed by the part typehash as a u64 BE before the part bytes.

pub fn from_framed(buf: Bytes) -> Result<Self, Error>

Reassembles a message from a framed encoding.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Message

fn eq(&self, other: &Message) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Message

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Message

impl StructuralPartialEq for Message