Struct tokio_zmq::Multipart

pub struct Multipart { /* fields omitted */ }

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

#![feature(try_from)]

extern crate zmq;
extern crate tokio_zmq;

use std::convert::{TryFrom, TryInto};

use tokio_zmq::Multipart;

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

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

impl TryFrom<Multipart> for Envelope {
    type Error = Error;

    fn try_from(mut multipart: Multipart) -> Result<Self, 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 = multipart.try_into().unwrap();

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

Methods

impl Multipart

fn new() -> Self

fn into_inner(self) -> VecDeque<Message>

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

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

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

fn push_front(&mut self, msg: Message)

fn push_back(&mut self, msg: Message)

fn is_empty(&self) -> bool

fn iter(&self) -> Iter<Message>

fn iter_mut(&mut self) -> IterMut<Message>

Trait Implementations

impl Debug for Multipart

fn fmt(&self, __arg_0: &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

Performs the conversion.

impl From<Vec<Message>> for Multipart

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

Performs the conversion.

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 IntoIterator for Multipart

type Item = Message

The type of the elements being iterated over.

type IntoIter = IntoIter<Message>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<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.