Enum MuxMessage 

pub enum MuxMessage {
    Register {
        protocol: ProtocolId<Erased>,
        frame: Frame,
        handler: StageRef<HandlerMessage>,
        max_buffer: usize,
    },
    Buffer(ProtocolId<Erased>, usize),
    Send(ProtocolId<Erased>, NonEmptyBytes, StageRef<Sent>),
    FromNetwork(Timestamp, ProtocolId<Erased>, NonEmptyBytes),
    Written,
    WantNext(ProtocolId<Erased>),
    Terminate,
}

Variants

Register

Register the given protocol with its ID so that data will be fed into it

Note that the handler explicitly needs to request each network message by sending WantNext. This is necessary to allow proper handling of TCP simultaneous open in the handshake protocol.

Fields

protocol: ProtocolId<Erased>

frame: Frame

handler: StageRef<HandlerMessage>

max_buffer: usize

Buffer(ProtocolId<Erased>, usize)

Buffer incoming data for this protocol ID up to the given limit (this should be followed by Register eventually, to then consume the data)

Setting the size to zero means that data are dropped without begin buffered and without tearing down the connection.

Send(ProtocolId<Erased>, NonEmptyBytes, StageRef<Sent>)

Send the given message on the protocol ID and notify when enqueued in TCP buffer

FromNetwork(Timestamp, ProtocolId<Erased>, NonEmptyBytes)

internal message coming from the TCP stream reader

Written

Notify that the segment has been written to the TCP stream

WantNext(ProtocolId<Erased>)

Permit the next invocation of the Protocol with data from the network.

Terminate

Reading or writing error occurred

Trait Implementations

impl Debug for MuxMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MuxMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MuxMessage

fn eq(&self, other: &MuxMessage) -> 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 MuxMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MuxMessage