Struct MessageQueueBroker

pub struct MessageQueueBroker<T: Hash + Eq, M> { /* private fields */ }

Lock free in memory message queue broker for sending values between asynchronous tasks by tags.

Implementations

impl<T, M> MessageQueueBroker<T, M>

where T: Hash + Eq + Clone,

pub fn unbounded() -> Self

Creates unbounded broker.

pub fn bounded(cap: usize) -> Self

Creates bounded broker.

pub fn subscribe(&self, tag: T) -> Subscriber<T, M>

Subscribes to the tag.

If a queue with provided tag already exists, a new subscriber to it will be created, otherwise a new queue will be created.

Until the queue with provided tag has been created (no one has subscribed), all attempts to send a message will fail.

impl<T, M> MessageQueueBroker<T, M>

where T: Hash + Eq,

pub fn close(&self)

Closes the broker. Sends and receives will fail.

pub fn is_closed(&self) -> bool

Checks if the broker is closed.

pub fn len(&self) -> usize

Gets the global queue length.

pub fn is_empty(&self) -> bool

Checks if the global queue is empty.

pub fn try_send<Q>(&self, tag: &Q, msg: M) -> Result<(), TrySendError<M>>

where Q: Hash + Equivalent<T> + ?Sized,

Trying to send a message with the tag.

If broker is closed, or there are no any subscriber to provided tag then returns TrySendError::Closed(_). If the tagged queue is full then returns TrySendError::Full(_).

Ok

use mqb::MessageQueueBroker;

let mqb = MessageQueueBroker::unbounded();
let sub = mqb.subscribe(1);

assert!(mqb.try_send(&1, 1).is_ok());
assert_eq!(sub.try_recv().unwrap(), 1);

No subscribers

use mqb::{MessageQueueBroker, TrySendError};

let mqb = MessageQueueBroker::<i32, i32>::unbounded();

assert_eq!(mqb.try_send(&1, 1).unwrap_err(), TrySendError::Closed(1));

Broker closed

use mqb::{MessageQueueBroker, TrySendError};

let mqb = MessageQueueBroker::unbounded();
let sub = mqb.subscribe(1);

mqb.close();
assert_eq!(mqb.try_send(&1, 1).unwrap_err(), TrySendError::Closed(1));

Queue is full

use mqb::{MessageQueueBroker, TrySendError};

let mqb = MessageQueueBroker::bounded(1);
let sub = mqb.subscribe(1);

assert!(mqb.try_send(&1, 1).is_ok());
assert_eq!(mqb.try_send(&1, 1).unwrap_err(), TrySendError::Full(1));

pub async fn send<Q>(&self, tag: &Q, msg: M) -> Result<(), SendError<M>>

where Q: Hash + Equivalent<T> + ?Sized,

Sends a message with the tag.

If broker is closed, or there are no any subscriber to provided tag then returns TrySendError::Closed(_). If the tagged queue is full, it will wait until a slot becomes available.

Ok

use mqb::MessageQueueBroker;

let mqb = MessageQueueBroker::unbounded();
let sub = mqb.subscribe(1);

assert!(mqb.send(&1, 1).await.is_ok());
assert_eq!(sub.recv().await.unwrap(), 1);

No subscribers

use mqb::{MessageQueueBroker, SendError};

let mqb = MessageQueueBroker::<i32, i32>::unbounded();

assert_eq!(mqb.send(&1, 1).await.unwrap_err(), SendError(1));

Broker closed

use mqb::{MessageQueueBroker, SendError};

let mqb = MessageQueueBroker::unbounded();
let sub = mqb.subscribe(1);

mqb.close();
assert_eq!(mqb.send(&1, 1).await.unwrap_err(), SendError(1));

Queue is full

use mqb::{MessageQueueBroker, TrySendError};

let mqb = MessageQueueBroker::bounded(1);
let sub = mqb.subscribe(1);

assert!(mqb.send(&1, 1).await.is_ok());
// Wait endlessly...
mqb.send(&1, 2).await;

Trait Implementations

impl<T: Debug + Hash + Eq, M: Debug> Debug for MessageQueueBroker<T, M>

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

Formats the value using the given formatter.

impl<T, M> Drop for MessageQueueBroker<T, M>

where T: Hash + Eq,

fn drop(&mut self)

Executes the destructor for this type.