feat: v1.1.0

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "udp"
-version = "1.0.5"
+version = "1.1.0"
 edition = "2024"
 authors = ["root@ltpp.vip"]
 license = "MIT"
@@ -18,7 +18,7 @@ exclude = [
 ]
 
 [dependencies]
-tokio = { version = "1.46.1", features = ["full"] }
+tokio = { version = "1.47.0", features = ["full"] }
 
 [profile.dev]
 incremental = false

src/common/const.rs

@@ -1,4 +1,5 @@
 use crate::*;
 
+/// Default socket address (0.0.0.0:0).
 pub const DEFAULT_SOCKET_ADDR: SocketAddr =
     SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 0));

src/common/type.rs

@@ -1,3 +1,4 @@
 use crate::*;
 
+/// Thread-safe reference-counted read-write lock wrapper.
 pub type ArcRwLock<T> = Arc<RwLock<T>>;

src/config/impl.rs

@@ -1,6 +1,12 @@
 use crate::*;
 
+/// Default implementation for ServerConfig.
 impl Default for ServerConfig {
+    /// Creates a default server configuration.
+    ///
+    /// # Returns
+    ///
+    /// - `ServerConfig` - New config with default values.
     fn default() -> Self {
         Self {
             host: DEFAULT_HOST.to_owned(),

src/config/struct.rs

@@ -1,9 +1,16 @@
 use crate::*;
 
+/// Server configuration settings.
+///
+/// Contains all necessary parameters to configure a UDP server.
 #[derive(Clone)]
 pub struct ServerConfig {
+    /// Server host address.
     pub(crate) host: String,
+    /// Server port number.
     pub(crate) port: usize,
+    /// Maximum buffer size for incoming packets.
     pub(crate) buffer_size: usize,
+    /// Error handling callback function.
     pub(crate) error_handle: ArcErrorHandle,
 }

src/config/type.rs

@@ -1,3 +1,4 @@
 use crate::*;
 
+/// Thread-safe read-write locked server configuration.
 pub type ArcRwLockServerConfig = ArcRwLock<ServerConfig>;

src/context/impl.rs

@@ -1,6 +1,12 @@
 use crate::*;
 
+/// Implementation of InnerContext methods.
 impl InnerContext {
+    /// Creates a new InnerContext with default values.
+    ///
+    /// # Returns
+    ///
+    /// - `InnerContext` - New context instance.
     pub fn new() -> Self {
         InnerContext {
             socket: None,
@@ -12,39 +18,91 @@ impl InnerContext {
     }
 }
 
+/// Implementation of Context methods.
+///
+/// Provides thread-safe operations on the UDP context.
 impl Context {
+    /// Creates a Context from an InnerContext.
+    ///
+    /// # Arguments
+    ///
+    /// - `InnerContext` - The inner context to wrap.
+    ///
+    /// # Returns
+    ///
+    /// - `Context` - New thread-safe context wrapper.
     pub(crate) fn from_inner_context(ctx: InnerContext) -> Self {
         Self(Arc::new(RwLock::new(ctx)))
     }
 
+    /// Acquires a read lock on the inner context.
+    ///
+    /// # Returns
+    ///
+    /// - `RwLockReadContext` - Read guard for the inner context.
     pub async fn get_read_lock(&self) -> RwLockReadContext {
         self.0.read().await
     }
 
+    /// Acquires a write lock on the inner context.
+    ///
+    /// # Returns
+    ///
+    /// - `RwLockWriteContext` - Write guard for the inner context.
     pub async fn get_write_lock(&self) -> RwLockWriteContext {
         self.0.write().await
     }
 
+    /// Gets a clone of the inner context.
+    ///
+    /// # Returns
+    ///
+    /// - `InnerContext` - Clone of the inner context.
     pub async fn get(&self) -> InnerContext {
         self.get_read_lock().await.clone()
     }
 
+    /// Gets the request data from the context.
+    ///
+    /// # Returns
+    ///
+    /// - `Request` - Clone of the request data.
     pub async fn get_request(&self) -> Request {
         self.get().await.request.clone()
     }
 
+    /// Gets the response data from the context.
+    ///
+    /// # Returns
+    ///
+    /// - `Response` - Clone of the response data.
     pub async fn get_response(&self) -> Response {
         self.get().await.response.clone()
     }
 
+    /// Gets the UDP socket from the context.
+    ///
+    /// # Returns
+    ///
+    /// - `OptionArcRwLockUdpSocket` - Clone of the socket if present.
     pub async fn get_socket(&self) -> OptionArcRwLockUdpSocket {
         self.get().await.socket.clone()
     }
 
+    /// Gets the socket address from the context.
+    ///
+    /// # Returns
+    ///
+    /// - `OptionSocketAddr` - Clone of the socket address if present.
     pub async fn get_socket_addr(&self) -> OptionSocketAddr {
         self.get().await.socket_addr.clone()
     }
 
+    /// Gets the socket address or default if not present.
+    ///
+    /// # Returns
+    ///
+    /// - `SocketAddr` - Socket address or default (0.0.0.0:0).
     pub async fn get_socket_addr_or_default(&self) -> SocketAddr {
         let socket_result: OptionArcRwLockUdpSocket = self.get_socket().await;
         if socket_result.is_none() {
@@ -59,31 +117,69 @@ impl Context {
         socket_addr
     }
 
+    /// Gets the socket address as a string.
+    ///
+    /// # Returns
+    ///
+    /// - `Option<String>` - Socket address string if present.
     pub async fn get_socket_addr_string(&self) -> Option<String> {
         self.get_socket_addr().await.map(|data| data.to_string())
     }
 
+    /// Gets the socket address or default as a string.
+    ///
+    /// # Returns
+    ///
+    /// - `String` - Socket address string or default.
     pub async fn get_socket_addr_or_default_string(&self) -> String {
         self.get_socket_addr_or_default().await.to_string()
     }
 
+    /// Gets the socket host IP address.
+    ///
+    /// # Returns
+    ///
+    /// - `OptionSocketHost` - Host IP address if present.
     pub async fn get_socket_host(&self) -> OptionSocketHost {
         self.get_socket_addr()
             .await
             .map(|socket_addr: SocketAddr| socket_addr.ip())
     }
 
+    /// Gets the socket port number.
+    ///
+    /// # Returns
+    ///
+    /// - `OptionSocketPort` - Port number if present.
     pub async fn get_socket_port(&self) -> OptionSocketPort {
         self.get_socket_addr()
             .await
             .map(|socket_addr: SocketAddr| socket_addr.port())
     }
 
+    /// Sets the response data in the context.
+    ///
+    /// # Arguments
+    ///
+    /// - `T` - Data convertible to ResponseData.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - Reference to self for chaining.
     pub(super) async fn set_response<T: Into<ResponseData>>(&self, data: T) -> &Self {
         self.get_write_lock().await.response = Response::from(data);
         self
     }
 
+    /// Sends response data through the socket.
+    ///
+    /// # Arguments
+    ///
+    /// - `T` - Data convertible to ResponseData.
+    ///
+    /// # Returns
+    ///
+    /// - `ResponseResult` - Result of the send operation.
     pub async fn send<T: Into<ResponseData>>(&self, data: T) -> ResponseResult {
         let response_result: ResponseResult = self
             .set_response(data)
@@ -95,6 +191,16 @@ impl Context {
         return response_result;
     }
 
+    /// Sets a value in the context data storage.
+    ///
+    /// # Arguments
+    ///
+    /// - `&str` - Key for the value.
+    /// - `&T` - Value to store (must be Any + Send + Sync + Clone).
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - Reference to self for chaining.
     pub async fn set_data_value<T: Any + Send + Sync + Clone>(
         &self,
         key: &str,
@@ -107,6 +213,15 @@ impl Context {
         self
     }
 
+    /// Gets a value from the context data storage.
+    ///
+    /// # Arguments
+    ///
+    /// - `&str` - Key for the value.
+    ///
+    /// # Returns
+    ///
+    /// - `Option<T>` - Retrieved value if present and of correct type.
     pub async fn get_data_value<T: Any + Send + Sync + Clone>(&self, key: &str) -> Option<T> {
         self.get_read_lock()
             .await
@@ -116,11 +231,25 @@ impl Context {
             .cloned()
     }
 
+    /// Removes a value from the context data storage.
+    ///
+    /// # Arguments
+    ///
+    /// - `&str` - Key for the value to remove.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - Reference to self for chaining.
     pub async fn remove_data_value(&self, key: &str) -> &Self {
         self.get_write_lock().await.data.remove(key);
         self
     }
 
+    /// Clears all data from the context data storage.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - Reference to self for chaining.
     pub async fn clear_data(&self) -> &Self {
         self.get_write_lock().await.data.clear();
         self

src/context/struct.rs

@@ -1,13 +1,27 @@
 use crate::*;
 
+/// Inner context containing all UDP communication components.
+///
+/// Stores the socket, request/response data and additional context information.
 #[derive(Clone)]
 pub struct InnerContext {
+    /// UDP socket wrapper with read-write lock.
     pub(crate) socket: OptionArcRwLockUdpSocket,
+    /// Incoming request data.
     pub(crate) request: Request,
+    /// Outgoing response data.
     pub(crate) response: Response,
+    /// Remote socket address.
     pub(crate) socket_addr: OptionSocketAddr,
+    /// Additional context data storage.
     pub(crate) data: HashMapArcAnySendSync,
 }
 
+/// Thread-safe context wrapper for UDP operations.
+///
+/// Provides synchronized access to the inner context.
 #[derive(Clone)]
-pub struct Context(pub(super) ArcRwLock<InnerContext>);
+pub struct Context(
+    /// Thread-safe reference to inner context.
+    pub(super) ArcRwLock<InnerContext>,
+);

src/handler/fn.rs

@@ -1,3 +1,12 @@
+/// Default error handler that prints errors to stderr.
+///
+/// # Arguments
+///
+/// - `String` - The error message to be printed.
+///
+/// # Returns
+///
+/// - `()` - This function does not return any value.
 pub(crate) fn print_error_handle(error: String) {
     eprintln!("{}", error);
     let _ = std::io::Write::flush(&mut std::io::stderr());

src/handler/trait.rs

@@ -1,13 +1,22 @@
 use crate::*;
 
+/// Trait for error handling functions.
 pub trait ErrorHandle: Fn(String) {}
 
+/// Trait for async handler functions without Pin requirement.
+///
+/// # Generic Parameters
+///
+/// - `Fut` - Future type returned by the function.
 pub trait AsyncFuncWithoutPin<Fut>: Fn(Context) -> Fut + Send + Sync + 'static
 where
     Fut: Future<Output = ()> + Send + 'static,
 {
 }
 
+/// Trait for general handler functions.
+///
+/// Wraps async functions in Pin<Box<dyn Future>>.
 pub trait Func:
     Fn(Context) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> + Send + Sync + 'static
 {