Enum Reply 

pub enum Reply {
    Welcome {
        protocol: u16,
    },
    Refused(String),
    Met {
        path: Path,
        good_for: Option<Duration>,
    },
    Unreachable(String),
}

What the broker answers.

Variants

Welcome

The session is open, and this is the vocabulary I speak.

Fields

protocol: u16

Mine, so a mismatch can be reported with both numbers in it.

Refused(String)

No session, and here is why. Belongs to the session and not to a rendezvous: after this there is no conversation.

Met

You two have been introduced. Go and talk; I am out of it.

Fields

path: Path

How to reach them.

good_for: Option<Duration>

How long this rendezvous is good for, counting from when you read it. None is nobody is taking this back, which is every broker with no policy.

A duration and not an instant: an Instant does not serialize and means nothing off its own process, and a wall clock was already ruled out next door — two machines on a cluster disagree by minutes, so an expiry stamped there and read here would be a lease that expires in the past.

Unreachable(String)

That host cannot be reached, and here is why. Belongs to the rendezvous: the session survives it, and another host may well be fine.

Implementations

impl Reply

pub fn to_bytes(&self) -> Result<Vec<u8>, Unreadable>

This message in bytes.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Unreadable>

And back from them.

pub fn to_greeting(spoken: u16) -> Self

The answer to a greeting: Reply::Welcome if that is a vocabulary we speak, and a Reply::Refused naming both numbers if it is not.

Here and not in a broker because every broker owes the same answer, and three of them writing this comparison separately is three chances to write >= and accept a stranger.

Trait Implementations

impl Clone for Reply

fn clone(&self) -> Reply

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Reply

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Reply

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Reply

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Reply

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Reply

impl StructuralPartialEq for Reply