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

use std::net::SocketAddr;

use crate::types::{SendIdentityOverrides, SendOptions};

/// Request object for sending a message.
///
/// This combines destination, payload, transport options, and optional per-
/// message identity/auth overrides into one value to avoid combinatorial send
/// method signatures.
#[derive(Debug, Clone)]
pub struct SendRequest<'a> {
    pub(super) destination: SocketAddr,
    pub(super) data: &'a [u8],
    pub(super) options: SendOptions,
    pub(super) identity: SendIdentityOverrides,
}

impl<'a> SendRequest<'a> {
    #[must_use]
    pub fn new(destination: SocketAddr, data: &'a [u8]) -> Self {
        Self {
            destination,
            data,
            options: SendOptions::new(),
            identity: SendIdentityOverrides::new(),
        }
    }

    #[must_use]
    pub fn destination(&self) -> SocketAddr {
        self.destination
    }

    #[must_use]
    pub fn data(&self) -> &'a [u8] {
        self.data
    }

    #[must_use]
    pub fn options(&self) -> &SendOptions {
        &self.options
    }

    #[must_use]
    pub fn identity(&self) -> &SendIdentityOverrides {
        &self.identity
    }

    #[must_use]
    pub fn with_destination(mut self, destination: SocketAddr) -> Self {
        self.destination = destination;
        self
    }

    #[must_use]
    pub fn with_data<'b>(self, data: &'b [u8]) -> SendRequest<'b> {
        SendRequest {
            destination: self.destination,
            data,
            options: self.options,
            identity: self.identity,
        }
    }

    #[must_use]
    pub fn with_options(mut self, options: SendOptions) -> Self {
        self.options = options;
        self
    }

    #[must_use]
    pub fn with_identity(mut self, identity: SendIdentityOverrides) -> Self {
        self.identity = identity;
        self
    }
}