msrt 0.1.5

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Packet header structure.

pub mod ack;
pub mod body;
pub mod data;
pub mod flags;
pub mod len;
pub mod liveness;
pub mod log;

pub use ack::AckHeader;
pub use body::PacketHeaderBody;
pub use data::DataHeader;
pub use flags::Flags;
pub use len::{
    ACK_PACKET_HEADER_LEN, DATA_PACKET_HEADER_LEN, LIVENESS_PACKET_HEADER_LEN,
    LOG_PACKET_HEADER_LEN,
};
pub use liveness::{PingHeader, PongHeader};
pub use log::LogHeader;

use super::{PacketIndex, PacketKey, PacketType};

use crate::core::MessageId;

/// Metadata shared by every protocol packet.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PacketHeader {
    /// Packet type.
    pub packet_type: PacketType,
    /// Kind-specific header fields.
    pub body: PacketHeaderBody,
}

impl PacketHeader {
    /// Creates a DATA packet header.
    #[must_use]
    pub const fn data(
        packet_index: PacketIndex,
        flags: Flags,
        message_id: MessageId,
        message_len: usize,
        fragment_offset: usize,
    ) -> Self {
        Self {
            packet_type: PacketType::Data,
            body: PacketHeaderBody::Data {
                header: DataHeader::new(
                    flags,
                    message_id,
                    packet_index,
                    message_len,
                    fragment_offset,
                ),
            },
        }
    }

    /// Creates a DATA packet header from the target DATA header.
    #[must_use]
    pub const fn from_data_header(header: DataHeader) -> Self {
        Self::data(
            header.packet_index,
            header.flags,
            header.message_id,
            header.message_len,
            header.fragment_offset,
        )
    }

    /// Creates a LOG packet header.
    #[must_use]
    pub const fn log(
        packet_index: PacketIndex,
        message_id: MessageId,
        message_len: usize,
        fragment_offset: usize,
    ) -> Self {
        Self {
            packet_type: PacketType::Log,
            body: PacketHeaderBody::Log {
                header: LogHeader::new(message_id, packet_index, message_len, fragment_offset),
            },
        }
    }

    /// Creates a LOG packet header from the target LOG header.
    #[must_use]
    pub const fn from_log_header(header: LogHeader) -> Self {
        Self::log(
            header.packet_index,
            header.message_id,
            header.message_len,
            header.fragment_offset,
        )
    }

    /// Creates an ACK packet header.
    #[must_use]
    pub const fn ack(key: PacketKey) -> Self {
        Self {
            packet_type: PacketType::Ack,
            body: PacketHeaderBody::Ack {
                header: AckHeader::new(key.message_id, key.packet_index),
            },
        }
    }

    /// Creates a PING packet header.
    #[must_use]
    pub const fn ping() -> Self {
        Self {
            packet_type: PacketType::Ping,
            body: PacketHeaderBody::Ping {
                header: PingHeader::new(),
            },
        }
    }

    /// Creates a PONG packet header.
    #[must_use]
    pub const fn pong() -> Self {
        Self {
            packet_type: PacketType::Pong,
            body: PacketHeaderBody::Pong {
                header: PongHeader::new(),
            },
        }
    }

    /// Returns whether this packet kind can carry payload bytes.
    #[must_use]
    pub const fn can_carry_payload(self) -> bool {
        matches!(self.packet_type, PacketType::Data | PacketType::Log)
    }
}