Struct Mailbox

pub struct Mailbox<SenderMessage: Send + Sync, ReceiverMessage: Send + Sync> { /* private fields */ }

An object that has the ability to act as a two-way channel. This allows for two-way communications across threads, for example.

Implementations

impl<MessageA: Send + Sync + 'static, MessageB: Send + Sync + 'static> Mailbox<MessageA, MessageB>

pub fn new_entangled_pair() -> (Mailbox<MessageA, MessageB>, Mailbox<MessageB, MessageA>)

Creates a new pair of Mailboxs in the form of (Mailbox<MessageA, MessageB>, Mailbox<MessageB, MessageA>)

Example

let (renderer_mailbox, game_mailbox) = Mailbox::new_entangled_pair();

renderer_mailbox.send(RenderLoopMessage::SyncWithGame);
if let Ok(RenderLoopMessage::SyncWithGame) = game_mailbox.poll() {
    // ...
}
 
game_mailbox.send_and_wait(GameLoopMessage::SyncWithRender)?;

impl<SenderMessage: Send + Sync, ReceiverMessage: Send + Sync> Mailbox<SenderMessage, ReceiverMessage>

pub fn new( sender: Sender<SenderMessage>, receiver: Receiver<ReceiverMessage>, ) -> Self

Creates a new Mailbox. Since new_entangled_pair() exists, this is only exposed in case that doesn’t cover your use case. Otherwise you should just use that method instead.

Example

let (sender_a, receiver_a) = std::sync::mpsc::channel();
let (sender_b, receiver_b) = std::sync::mpsc::channel();

let renderer_mailbox = Mailbox::new(sender_a, receiver_b);
let game_mailbox = Mailbox::new(sender_b, receiver_a);

renderer_mailbox.send(RenderLoopMessage::SyncWithGame);
if let Ok(RenderLoopMessage::SyncWithGame) = game_mailbox.poll() {
    // ...
}
 
game_mailbox.send_and_wait(GameLoopMessage::SyncWithRender)?;

pub fn send( &self, message: SenderMessage, ) -> Result<(), MessagingError<SenderMessage>>

Sends a message through the held sender. Wrapper around sender.send()

pub fn wait(&mut self) -> Result<ReceiverMessage, MessagingError<SenderMessage>>

Waits for a message from the held receiver. Wrapper around receiver.recv()

pub fn poll(&mut self) -> Result<ReceiverMessage, MessagingError<SenderMessage>>

Polls for a message from the held receiver, otherwise immediately returning. Wrapper around receiver.try_recv()

pub fn send_and_wait( &mut self, message: SenderMessage, ) -> Result<ReceiverMessage, MessagingError<SenderMessage>>

Does a send and a wait. Good for syncing between two threads.

Trait Implementations

impl<SenderMessage: Debug + Send + Sync, ReceiverMessage: Debug + Send + Sync> Debug for Mailbox<SenderMessage, ReceiverMessage>

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

Formats the value using the given formatter.