Trait StreamSocket

pub trait StreamSocket: IntoInnerSocket {
    // Provided methods
    fn recv(
        self,
    ) -> <<Self as IntoInnerSocket>::Socket as InnerSocket<Self>>::Response { ... }
    fn stream(
        self,
    ) -> <<Self as IntoInnerSocket>::Socket as InnerSocket<Self>>::Stream { ... }
}

This trait provides the basic Stream support for ZeroMQ Sockets. It depends on IntoInnerSocket, but provides implementations for sink and recv.

Provided Methods

fn recv( self, ) -> <<Self as IntoInnerSocket>::Socket as InnerSocket<Self>>::Response

Receive a single multipart message from the socket.

Example, using the Rep wrapper type

extern crate futures;
extern crate tokio;
extern crate tokio_zmq;
extern crate zmq;

use std::sync::Arc;

use futures::Future;
use tokio_zmq::{prelude::*, async_types::MultipartStream, Error, Multipart, Rep};

fn main() {
    let context = Arc::new(zmq::Context::new());

    let fut = Rep::builder(context)
        .connect("tcp://localhost:5568")
        .build()
        .and_then(|rep| {
            rep.recv().and_then(|(multipart, _)| {
                for msg in &multipart {
                    if let Some(msg) = msg.as_str() {
                        println!("Message: {}", msg);
                    }
                }
                Ok(multipart)
            })
        });

    // tokio::run(fut.map(|_| ()).or_else(|e| {
    //     println!("Error: {}", e);
    //     Ok(())
    // }));
}

fn stream( self, ) -> <<Self as IntoInnerSocket>::Socket as InnerSocket<Self>>::Stream

Receive a stream of multipart messages from the socket.

Example, using a Sub wrapper type

extern crate zmq;
extern crate futures;
extern crate tokio;
extern crate tokio_zmq;

use std::sync::Arc;

use futures::{Future, Stream};
use tokio_zmq::{prelude::*, async_types::MultipartStream, Error, Multipart, Sub};

fn main() {
    let context = Arc::new(zmq::Context::new());
    let fut = Sub::builder(context)
        .connect("tcp://localhost:5569")
        .filter(b"")
        .build()
        .and_then(|sub| {
            sub.stream().for_each(|multipart| {
                for msg in multipart {
                    if let Some(msg) = msg.as_str() {
                        println!("Message: {}", msg);
                    }
                }
                Ok(())
            })
        });

    // tokio::run(fut.map(|_| ()).or_else(|e| {
    //     println!("Error: {}", e);
    //     Ok(())
    // }));
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors