Struct Embedded 

pub struct Embedded { /* private fields */ }

A broker running on a thread of this process.

Implementations

impl Embedded

pub fn open(listing: impl IntoIterator<Item = (Host, Path)>) -> Self

A broker that knows where these hosts are.

The listing is fixed when the broker opens and the thread owns it, which is why there is no lock around it and no way for two threads to disagree about where w1 is. A host that has to be added is a broker that has to be opened.

pub fn served_by(desk: impl FnMut(Ask) -> Reply + Send + 'static) -> Self

A broker whose answers come from desk.

Public for one reason, and a present one: the worst thing this type can do is turn a panic into a hang, and there is no way to test that a desk which fails is reported as a failure without being able to stand one up.

pub fn greet(&self) -> Result<(), Unanswered>

Opens the session, if it was not open.

Idempotent on purpose: whoever needs a rendezvous calls this first and does not have to know whether somebody else already did. A refusal is a refusal of the session, which is why it is not swallowed and retried.

pub fn ask(&self, ask: &Ask) -> Result<Reply, Unanswered>

Says something and waits for the answer.

Every message has exactly one answer except Ask::Done, which has none — use Embedded::done for that one. Asking it here is refused rather than waited on, because the alternative is the hang this type is built not to have.

pub fn done(&self, host: &Host) -> Result<(), Unanswered>

Lets a rendezvous go. Nothing answers, and nothing is waited for.

An embedded broker holds nothing, so nothing is released. It is sent anyway because the same client code talks to a broker that does hold things.

Trait Implementations

impl Drop for Embedded

fn drop(&mut self)

Lets the channel go, then waits for the thread. In that order: the thread’s loop ends when the last sender is dropped, so joining first would be waiting for something that is waiting for us.