Struct libzmq::Radio

pub struct Radio { /* fields omitted */ }

A Radio socket is used by a publisher to distribute data to Dish sockets.

Each message sent belong to a group. By default, the group is "". This group can be specified by using set_group or using the convenience method transmit. Messages are distributed to all members of a group.

Mute State

When a Radio socket enters the mute state due to having reached the high water mark for a subscriber, then any messages that would be sent to the subscriber in question shall instead be dropped until the mute state ends.

Summary of Characteristics

Characteristic	Value
Compatible peer sockets	Dish
Direction	Unidirectional
Send/receive pattern	Send only
Incoming routing strategy	N/A
Outgoing routing strategy	Fan out
Action in mute state	Drop

Example

use libzmq::{prelude::*, *};
use std::{thread, time::Duration};

let addr: TcpAddr = "127.0.0.1:*".try_into()?;

let radio = RadioBuilder::new()
    .bind(addr)
    .build()?;

let bound = radio.last_endpoint().unwrap();
let a: Group = "A".try_into()?;
let b: Group = "B".try_into()?;

let dish_a = DishBuilder::new()
    .connect(&bound)
    .join(&a)
    .build()?;

let dish_b = DishBuilder::new()
    .connect(bound)
    .join(&b)
    .build()?;

// Start the feed. It has no conceptual start nor end, thus we
// don't synchronize with the subscribers.
thread::spawn(move || {
    let a: Group = "A".try_into().unwrap();
    let b: Group = "B".try_into().unwrap();
    let mut count = 0;
    loop {
        let msg = Msg::new();
        // Alternate between the two groups.
        let group = if count % 2 == 0 {
            &a
        } else {
            &b
        };

        radio.transmit(msg, group).unwrap();

        thread::sleep(Duration::from_millis(1));
        count += 1;
    }
});

// Each dish will only receive the messages from their respective groups.
let msg = dish_a.recv_msg()?;
assert_eq!(msg.group().unwrap(), &a);

let msg = dish_b.recv_msg()?;
assert_eq!(msg.group().unwrap(), &b);

Methods

impl Radio

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

Create a Radio socket from the global context

Returned Error Variants

• CtxTerminated
• SocketLimit

pub fn with_ctx<C>(ctx: C) -> Result<Self, Error> where
    C: Into<Ctx>, 

Create a Radio socket from a specific context.

Returned Error Variants

• CtxTerminated
• SocketLimit

pub fn ctx(&self) -> &Ctx

Returns a reference to the context of the socket.

pub fn no_drop(&self) -> Result<bool, Error>

Returns true if the no_drop option is set.

pub fn set_no_drop(&self, enabled: bool) -> Result<(), Error>

Sets the socket's behaviour to block instead of drop messages when in the mute state.

Default value

false

pub fn transmit<M, G>(&self, msg: M, group: G) -> Result<(), Error<Msg>> where
    M: Into<Msg>,
    G: AsRef<GroupSlice>, 

Push a message into the outgoing socket queue with the specified group.

This is a convenience function that sets the Msg's group then sends it.

See send for more information.

pub fn try_transmit<M, G>(&self, msg: M, group: G) -> Result<(), Error<Msg>> where
    M: Into<Msg>,
    G: AsRef<GroupSlice>, 

Try to push a message into the outgoing socket queue with the specified group.

This is a convenience function that sets the Msg's group then tries sends it.

See try_send for more information.

Trait Implementations

impl SendMsg for Radio

fn send<M>(&self, msg: M) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Push a message into the outgoing socket queue.

fn try_send<M>(&self, msg: M) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Try to push a message into the outgoing socket queue without blocking.

fn send_high_water_mark(&self) -> Result<Quantity, Error>

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

fn set_send_high_water_mark<Q>(&self, qty: Q) -> Result<(), Error> where
    Q: Into<Quantity>, 

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

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

Sets the timeout for [send] on the socket.

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

Sets the timeout for [send] on the socket.

impl Socket for Radio

fn connect<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Schedules a connection to one or more [Endpoints] and then accepts incoming connections.

fn bind<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Schedules a bind to one or more [Endpoints] and then accepts incoming connections.

fn disconnect<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Disconnect the socket from one or more [Endpoints].

fn last_endpoint(&self) -> Result<Option<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]. # Example ``` # use failure::Error; # # fn main() -> Result<(), Error> { use libzmq::{prelude::, Client, auth::};

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

Returns a the socket's heartbeat configuration.

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

Set the socket's heartbeat configuration.

impl Sync for Radio

impl Eq for Radio

impl Send for Radio

impl PartialEq<Radio> for Radio

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

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

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

This method tests for !=.

impl Clone for Radio

fn clone(&self) -> Radio

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn from(radio: &'a Radio) -> Self

Performs the conversion.

impl Debug for Radio

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

Formats the value using the given formatter.