msrt 0.1.1

Portable MSRT protocol implementation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Engine events.

use crate::core::{ChannelId, PacketNumber};
use crate::reliability::{MessageKey, PacketReliabilityEvent};

use crate::engine::time::Instant;

/// Lightweight event kind without associated data.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EngineEventKind {
    /// A full message can be delivered to the caller.
    MessageReceived,
    /// Protocol bytes should be written to the lower link.
    LinkWrite,
    /// An ACK response should be generated.
    AckRequired,
    /// A packet should be retransmitted.
    Retransmit,
    /// The engine wants to be ticked later.
    WakeAt,
    /// A reliability event occurred.
    Reliability,
}

/// Events emitted by the protocol engine to its embedding environment.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EngineEvent {
    /// A complete message is available for a channel.
    MessageReceived {
        /// Channel that owns the message.
        channel_id: ChannelId,
        /// Message identity on the channel.
        message_key: MessageKey,
    },
    /// A protocol response should be written to the lower link.
    LinkWrite,
    /// An ACK response should be generated for a packet.
    AckRequired {
        /// Packet number that should be acknowledged.
        packet_number: PacketNumber,
    },
    /// A retransmission became due.
    Retransmit {
        /// Packet number selected for retransmission.
        packet_number: PacketNumber,
    },
    /// The engine needs to be ticked again at a later instant.
    WakeAt(Instant),
    /// A packet-level reliability event occurred.
    Reliability(PacketReliabilityEvent),
}

impl EngineEvent {
    /// Returns this event's kind.
    #[must_use]
    pub const fn kind(self) -> EngineEventKind {
        match self {
            Self::MessageReceived { .. } => EngineEventKind::MessageReceived,
            Self::LinkWrite => EngineEventKind::LinkWrite,
            Self::AckRequired { .. } => EngineEventKind::AckRequired,
            Self::Retransmit { .. } => EngineEventKind::Retransmit,
            Self::WakeAt(_) => EngineEventKind::WakeAt,
            Self::Reliability(_) => EngineEventKind::Reliability,
        }
    }
}