Struct libzmq::Gather

pub struct Gather { /* fields omitted */ }

A Gather socket is used to receive pipelined messages.

Messages are fair-queued from among all connected Scatter sockets.

Summary of Characteristics

Characteristic	Value
Compatible peer sockets	Scatter
Direction	Unidirectional
Send/receive pattern	Receive only
Outgoing routing strategy	Round-robin
Incoming routing strategy	Fair-queued
Action in mute state	Block

Example

use libzmq::{prelude::*, *};

let addr_a = InprocAddr::new_unique();
let addr_b = InprocAddr::new_unique();

// Create our two load balancers.
let lb_a = ScatterBuilder::new()
    .bind(&addr_a)
    .build()?;
let lb_b = ScatterBuilder::new()
    .bind(&addr_b)
    .build()?;

// Connect the worker to both load balancers.
let worker = GatherBuilder::new()
    .connect(&[addr_a, addr_b])
    .recv_hwm(1)
    .build()?;

for _ in 0..100 {
    lb_a.try_send("a")?;
}
for _ in 0..100 {
    lb_b.try_send("b")?;
}

// The messages received should be fair-queues from
// our two load balancers.
let mut msg = Msg::new();
for i in 0..200 {
    worker.try_recv(&mut msg)?;
    if i % 2 == 0 {
        assert_eq!(msg.to_str(), Ok("a"));
    } else {
        assert_eq!(msg.to_str(), Ok("b"));
    }
}

Implementations

impl Gather

pub fn new() -> Result<Self, Error>

Create a Gather socket from the global context

Returned Error Variants

• InvalidCtx
• SocketLimit

pub fn with_ctx(handle: CtxHandle) -> Result<Self, Error>

Create a Gather socket associated with a specific context from a CtxHandle.

Returned Error Variants

• InvalidCtx
• SocketLimit

pub fn ctx(&self) -> CtxHandle

Returns a handle to the context of the socket.

Trait Implementations

impl Clone for Gather

fn clone(&self) -> Gather

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Gather

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

Formats the value using the given formatter.

impl Eq for Gather

impl<'a> From<&'a Gather> for Pollable<'a>

fn from(gather: &'a Gather) -> Self

Performs the conversion.

impl Heartbeating for Gather

fn heartbeat(&self) -> Option<Heartbeat>

Returns a the socket's heartbeating configuration.

fn set_heartbeat(&self, maybe: Option<Heartbeat>) -> Result<(), Error>

Sets the socket's heartbeating configuration.

impl PartialEq<Gather> for Gather

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl RecvMsg for Gather

fn recv(&self, msg: &mut Msg) -> Result<(), Error>

Retreive a message from the inbound socket queue.

fn try_recv(&self, msg: &mut Msg) -> Result<(), Error>

Try to retrieve a message from the inbound socket queue without blocking.

fn recv_msg(&self) -> Result<Msg, Error>

A convenience function that allocates a [Msg] with the same properties as [recv].

fn try_recv_msg(&self) -> Result<Msg, Error>

A convenience function that allocates a [Msg] with the same properties as [try_recv].

fn recv_hwm(&self) -> Result<i32, Error>

The high water mark for incoming messages on the specified socket.

fn set_recv_hwm(&self, hwm: i32) -> Result<(), Error>

Set the high water mark for inbound messages on the specified socket.

fn recv_timeout(&self) -> Result<Period, Error>

The timeout for [recv] on the socket.

fn set_recv_timeout<P>(&self, period: P) -> Result<(), Error> where
    P: Into<Period>, 

Sets the timeout for [recv] on the socket.

impl Send for Gather

impl Socket for Gather

fn connect<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Schedules a connection to a Endpoint.

fn bind<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Schedules a bind to a Endpoint and then accepts incoming connections.

fn disconnect<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Disconnect the socket from a Endpoint.

fn unbind<I, E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Unbind the socket from a Endpoint.

fn last_endpoint(&self) -> Result<Endpoint, Error>

Retrieve the last endpoint connected or bound to.

fn mechanism(&self) -> Mechanism

Returns the socket's [Mechanism].

fn set_mechanism<M>(&self, mechanism: M) -> Result<(), Error> where
    M: Into<Mechanism>, 

Set the socket's [Mechanism].

impl Sync for Gather