Struct async_zmq_types::Multipart

pub struct Multipart { /* private fields */ }

This type is used for receiving and sending messages in Multipart groups. An application could make using this easier by implementing traits as follows:

extern crate zmq;
extern crate tokio_zmq;

use tokio_zmq::Multipart;

#[derive(Debug)]
enum Error {
    NotEnoughMessages,
    TooManyMessages,
}

struct Envelope {
    filter: zmq::Message,
    address: zmq::Message,
    body: zmq::Message,
}

impl Envelope {
    fn from_multipart(mut multipart: Multipart) -> Result<Self, Error> {
        let filter = multipart.pop_front().ok_or(Error::NotEnoughMessages)?;
        let address = multipart.pop_front().ok_or(Error::NotEnoughMessages)?;
        let body = multipart.pop_front().ok_or(Error::NotEnoughMessages)?;

        if !multipart.is_empty() {
            return Err(Error::TooManyMessages);
        }

        Ok(Envelope {
            filter,
            address,
            body,
        })
    }
}

impl From<Envelope> for Multipart {
    fn from(envelope: Envelope) -> Self {
        let mut multipart = Multipart::new();

        multipart.push_back(envelope.filter);
        multipart.push_back(envelope.address);
        multipart.push_back(envelope.body);

        multipart
    }
}

fn main() {
    let mut multipart: Multipart = Multipart::new();
    multipart.push_back(zmq::Message::from_slice(b"FILTER: asdf").unwrap());
    multipart.push_back(zmq::Message::from_slice(b"some.address").unwrap());
    multipart.push_back(zmq::Message::from_slice(b"Some content").unwrap());
    let envelope = Envelope::from_multipart(multipart).unwrap();

    let multipart2: Multipart = envelope.into();
}

Implementations

impl Multipart

pub fn new() -> Self

pub fn into_inner(self) -> VecDeque<Message>

pub fn get(&self, index: usize) -> Option<&Message>

pub fn pop_front(&mut self) -> Option<Message>

pub fn pop_back(&mut self) -> Option<Message>

pub fn push_front(&mut self, msg: Message)

pub fn push_back(&mut self, msg: Message)

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, Message>

pub fn len(&self) -> usize

pub fn iter_mut(&mut self) -> IterMut<'_, Message>

pub fn drain<R>(&mut self, range: R) -> Drain<'_, Message>where
    R: RangeBounds<usize>,

Trait Implementations

impl Debug for Multipart

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

Formats the value using the given formatter.

impl Default for Multipart

fn default() -> Self

Returns the “default value” for a type.

impl From<Message> for Multipart

fn from(msg: Message) -> Self

Converts to this type from the input type.

impl From<Vec<Message, Global>> for Multipart

fn from(v: Vec<Message>) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a Multipart

type Item = &'a Message

The type of the elements being iterated over.

type IntoIter = Iter<'a, Message>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, Message>

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Multipart

type Item = &'a mut Message

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Message>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, Message>

Creates an iterator from a value.

impl IntoIterator for Multipart

type Item = Message

The type of the elements being iterated over.

type IntoIter = IntoIter<Message, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<Message>

Creates an iterator from a value.