uniudp 1.0.0

Unidirectional UDP transport with chunking, redundancy, and Reed-Solomon FEC.
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

use std::fmt;

use crate::error::Result;
use crate::types::SenderId;

use super::{default_session_nonce, Sender, DEFAULT_MAX_TRACKED_SENDERS};

/// Strategy used to choose the first automatically-assigned `message_id` for a
/// sender instance.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum MessageIdStart {
    /// Start automatic allocation at `0`.
    #[default]
    Zero,
    /// Start automatic allocation at a random `u64` value.
    Random,
    /// Start automatic allocation at the provided `message_id`.
    Next(u64),
}

/// Builder for [`Sender`].
#[derive(Clone)]
pub struct SenderBuilder {
    sender_id: SenderId,
    session_nonce_strategy: SessionNonceStrategy,
    max_tracked_senders: usize,
    message_id_start: MessageIdStart,
}

impl Default for SenderBuilder {
    fn default() -> Self {
        Self {
            sender_id: SenderId(rand::random::<u128>()),
            session_nonce_strategy: SessionNonceStrategy::RandomDefault,
            max_tracked_senders: DEFAULT_MAX_TRACKED_SENDERS,
            message_id_start: MessageIdStart::Zero,
        }
    }
}

impl SenderBuilder {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn with_sender_id(mut self, sender_id: SenderId) -> Self {
        self.sender_id = sender_id;
        self
    }

    #[must_use]
    pub fn with_session_nonce(mut self, session_nonce: u64) -> Self {
        self.session_nonce_strategy = SessionNonceStrategy::Explicit(session_nonce);
        self
    }

    #[must_use]
    pub fn with_max_tracked_senders(mut self, max_tracked_senders: usize) -> Self {
        self.max_tracked_senders = max_tracked_senders;
        self
    }

    #[must_use]
    pub fn with_message_id_start(mut self, message_id_start: MessageIdStart) -> Self {
        self.message_id_start = message_id_start;
        self
    }

    pub fn build(self) -> Result<Sender> {
        let session_nonce = match &self.session_nonce_strategy {
            SessionNonceStrategy::RandomDefault => default_session_nonce(),
            SessionNonceStrategy::Explicit(session_nonce) => *session_nonce,
        };
        Sender::try_with_identity_and_limits_and_start(
            self.sender_id,
            session_nonce,
            self.max_tracked_senders,
            self.message_id_start,
        )
    }
}

#[derive(Clone)]
enum SessionNonceStrategy {
    RandomDefault,
    Explicit(u64),
}

impl fmt::Debug for SessionNonceStrategy {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SessionNonceStrategy::RandomDefault => f.write_str("RandomDefault"),
            SessionNonceStrategy::Explicit(session_nonce) => {
                f.debug_tuple("Explicit").field(session_nonce).finish()
            }
        }
    }
}

impl fmt::Debug for SenderBuilder {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SenderBuilder")
            .field("sender_id", &self.sender_id)
            .field("session_nonce_strategy", &self.session_nonce_strategy)
            .field("max_tracked_senders", &self.max_tracked_senders)
            .field("message_id_start", &self.message_id_start)
            .finish()
    }
}