udp 3.1.0

A lightweight and efficient Rust library for building UDP servers with request-response handling.
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

use crate::*;

/// Provides a default implementation for `ServerControlHook`.
impl Default for ServerControlHook {
    /// Creates a default `ServerControlHook` with no-op hooks.
    ///
    /// # Returns
    ///
    /// - `Self` - A new instance with default no-op hooks.
    #[inline(always)]
    fn default() -> Self {
        Self {
            wait_hook: Arc::new(|| Box::pin(async {})),
            shutdown_hook: Arc::new(|| Box::pin(async {})),
        }
    }
}

/// Implementation of methods for `ServerControlHook`.
impl ServerControlHook {
    /// Sets the wait hook.
    ///
    /// # Arguments
    ///
    /// - `hook` - The wait hook to set.
    pub(crate) fn set_wait_hook(
        &mut self,
        hook: Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync>,
    ) {
        self.wait_hook = hook;
    }

    /// Sets the shutdown hook.
    ///
    /// # Arguments
    ///
    /// - `hook` - The shutdown hook to set.
    pub(crate) fn set_shutdown_hook(
        &mut self,
        hook: Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync>,
    ) {
        self.shutdown_hook = hook;
    }

    /// Gets the wait hook.
    ///
    /// # Returns
    ///
    /// - `Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync>` - The wait hook.
    pub fn get_wait_hook(&self) -> Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync> {
        self.wait_hook.clone()
    }

    /// Gets the shutdown hook.
    ///
    /// # Returns
    ///
    /// - `Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync>` - The shutdown hook.
    pub fn get_shutdown_hook(&self) -> Arc<dyn Fn() -> SendableAsyncTask<()> + Send + Sync> {
        self.shutdown_hook.clone()
    }

    /// Waits for the server to finish.
    pub async fn wait(&self) {
        (self.get_wait_hook())().await;
    }

    /// Shuts down the server.
    pub async fn shutdown(&self) {
        (self.get_shutdown_hook())().await;
    }
}

/// Implementation of methods for `HandlerState`.
impl HandlerState {
    /// Creates a new HandlerState instance.
    ///
    /// # Arguments
    ///
    /// - `socket` - The network socket.
    ///
    /// # Returns
    ///
    /// - `Self` - The newly created handler state.
    #[inline(always)]
    pub(crate) fn new(socket: ArcRwLockUdpSocket) -> Self {
        Self { socket }
    }

    /// Gets the socket.
    ///
    /// # Returns
    ///
    /// - `ArcRwLockUdpSocket` - The network socket.
    pub(crate) fn get_socket(&self) -> ArcRwLockUdpSocket {
        self.socket.clone()
    }
}

/// Implementation of `ServerHook` for `DefaultServerHook`.
impl ServerHook for DefaultServerHook {
    /// Creates a new instance of `DefaultServerHook`.
    ///
    /// # Arguments
    ///
    /// - `_ctx` - The request context (unused).
    ///
    /// # Returns
    ///
    /// A future that resolves to a new `DefaultServerHook` instance.
    async fn new(_ctx: &Context) -> Self {
        Self
    }

    /// Executes the default hook's processing logic (no-op).
    ///
    /// # Arguments
    ///
    /// - `_ctx` - The request context (unused).
    async fn handle(self, _ctx: &Context) {}
}