feat: v3.0.0

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "udp"
-version = "2.0.12"
+version = "3.0.0"
 readme = "README.md"
 edition = "2024"
 authors = ["root@ltpp.vip"]

src/attribute/mod.rs

@@ -0,0 +1,3 @@
+mod r#type;
+
+pub use r#type::*;

src/attribute/type.rs

@@ -0,0 +1,14 @@
+use crate::*;
+
+/// Type alias for thread-safe attribute storage.
+///
+/// This type is used to store arbitrary data that can be shared across
+/// different parts of the application in a thread-safe manner.
+pub type ThreadSafeAttributeStore = HashMap<String, Arc<dyn Any + Send + Sync>>;
+
+/// Type alias for types that implement Any + Send + Sync + Clone.
+///
+/// This is a trait alias for types that can be stored in the attribute store
+/// and safely shared across threads.
+pub trait AnySendSyncClone: Any + Send + Sync + Clone {}
+impl<T> AnySendSyncClone for T where T: Any + Send + Sync + Clone {}

src/common/const.rs

@@ -1,4 +1,3 @@
-mod r#const;
 mod r#type;
 
-pub use {r#const::*, r#type::*};
+pub use r#type::*;

src/common/mod.rs

@@ -2,3 +2,17 @@ use crate::*;
 
 /// Thread-safe reference-counted read-write lock wrapper.
 pub type ArcRwLock<T> = Arc<RwLock<T>>;
+
+/// Helper function to wrap data in an `Arc<RwLock<T>>`.
+///
+/// # Arguments
+///
+/// - `T` - The data to wrap.
+///
+/// # Returns
+///
+/// - `ArcRwLock<T>` - The wrapped data.
+#[inline(always)]
+pub fn arc_rwlock<T>(data: T) -> ArcRwLock<T> {
+    Arc::new(RwLock::new(data))
+}

src/common/type.rs

@@ -1,19 +1,324 @@
 use crate::*;
 
-/// Default implementation for ServerConfig.
-impl Default for ServerConfig {
-    /// Creates a default server configuration.
+/// Default host address.
+pub const DEFAULT_HOST: &str = "0.0.0.0";
+/// Default UDP port.
+pub const DEFAULT_PORT: u16 = 60000;
+/// Default buffer size for UDP packets (512KB).
+pub const DEFAULT_BUFFER_SIZE: usize = 524288;
+/// Default `TCP_NODELAY` setting.
+pub const DEFAULT_NODELAY: Option<bool> = None;
+/// Default `IP_TTL` setting.
+pub const DEFAULT_TTL: Option<u32> = None;
+
+/// Provides a default implementation for ServerConfigData.
+impl Default for ServerConfigData {
+    /// Creates a new ServerConfigData instance with default values.
     ///
     /// # Returns
     ///
-    /// - `ServerConfig` - New config with default values.
+    /// - `Self` - A new instance with default configuration.
     #[inline(always)]
     fn default() -> Self {
         Self {
             host: DEFAULT_HOST.to_owned(),
-            port: DEFAULT_LISTEN_PORT,
+            port: DEFAULT_PORT,
             buffer_size: DEFAULT_BUFFER_SIZE,
-            error_handle: Arc::new(print_error_handle),
+            nodelay: DEFAULT_NODELAY,
+            ttl: DEFAULT_TTL,
         }
     }
 }
+
+/// Provides a default implementation for ServerConfig.
+impl Default for ServerConfig {
+    /// Creates a new ServerConfig instance with default values.
+    ///
+    /// # Returns
+    ///
+    /// - `Self` - A new instance wrapping default ServerConfigData.
+    #[inline(always)]
+    fn default() -> Self {
+        Self(arc_rwlock(ServerConfigData::default()))
+    }
+}
+
+/// Implements the `PartialEq` trait for `ServerConfig`.
+///
+/// This allows for comparing two `ServerConfig` instances for equality.
+impl PartialEq for ServerConfig {
+    /// Checks if two `ServerConfig` instances are equal.
+    ///
+    /// It first checks for pointer equality for performance. If the pointers are not equal,
+    /// it compares the inner `ServerConfigData` values.
+    ///
+    /// # Arguments
+    ///
+    /// - `&Self` - The other `ServerConfig` to compare against.
+    ///
+    /// # Returns
+    ///
+    /// - `bool` - Indicating whether the configurations are equal.
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        if Arc::ptr_eq(&self.0, &other.0) {
+            return true;
+        }
+        if let (Ok(s), Ok(o)) = (self.0.try_read(), other.0.try_read()) {
+            *s == *o
+        } else {
+            false
+        }
+    }
+}
+
+/// Implements the `Eq` trait for `ServerConfig`.
+///
+/// This indicates that `ServerConfig` has a total equality relation.
+impl Eq for ServerConfig {}
+
+/// Implementation of `From` trait for `ServerConfig`.
+impl From<ServerConfigData> for ServerConfig {
+    /// Creates a `ServerConfig` from a `ServerConfigData`.
+    ///
+    /// # Arguments
+    ///
+    /// - `ServerConfigData` - The configuration data.
+    ///
+    /// # Returns
+    ///
+    /// - `ServerConfig` - A `ServerConfig` instance.
+    #[inline(always)]
+    fn from(data: ServerConfigData) -> Self {
+        Self(arc_rwlock(data))
+    }
+}
+
+/// Implementation block for `ServerConfig`.
+impl ServerConfig {
+    /// Creates a new `ServerConfig` with default values.
+    ///
+    /// # Returns
+    ///
+    /// - `Self` - A new `ServerConfig` instance.
+    pub async fn new() -> Self {
+        Self::default()
+    }
+
+    /// Acquires a read lock on the server configuration.
+    ///
+    /// # Returns
+    ///
+    /// - `RwLockReadGuard<ServerConfigData>` - A read guard for the inner configuration.
+    async fn read(&self) -> RwLockReadGuard<'_, ServerConfigData> {
+        self.0.read().await
+    }
+
+    /// Acquires a write lock on the server configuration.
+    ///
+    /// # Returns
+    ///
+    /// - `RwLockWriteGuard<ServerConfigData>` - A write guard for the inner configuration.
+    async fn write(&self) -> RwLockWriteGuard<'_, ServerConfigData> {
+        self.0.write().await
+    }
+
+    /// Retrieves a clone of the inner server configuration.
+    ///
+    /// This function provides a snapshot of the current configuration by acquiring a read lock
+    /// and cloning the inner `ServerConfigData`.
+    ///
+    /// # Returns
+    ///
+    /// - `ServerConfigData` - A `ServerConfigData` instance containing the current server configuration.
+    pub(crate) async fn get_data(&self) -> ServerConfigData {
+        self.read().await.clone()
+    }
+
+    /// Sets the host address for the server.
+    ///
+    /// # Arguments
+    ///
+    /// - `H` - The host address to set.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn host<H>(&self, host: H) -> &Self
+    where
+        H: AsRef<str>,
+    {
+        self.write().await.host = host.as_ref().to_owned();
+        self
+    }
+
+    /// Sets the port for the server.
+    ///
+    /// # Arguments
+    ///
+    /// - `port` - The port number to set.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn port(&self, port: u16) -> &Self {
+        self.write().await.port = port;
+        self
+    }
+
+    /// Sets the buffer size for receiving UDP packets.
+    ///
+    /// # Arguments
+    ///
+    /// - `size` - The buffer size in bytes.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn buffer_size(&self, size: usize) -> &Self {
+        self.write().await.buffer_size = size;
+        self
+    }
+
+    /// Sets the `TCP_NODELAY` option.
+    ///
+    /// # Arguments
+    ///
+    /// - `nodelay` - The value for `TCP_NODELAY`.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn nodelay(&self, nodelay: bool) -> &Self {
+        self.write().await.nodelay = Some(nodelay);
+        self
+    }
+
+    /// Enables the `TCP_NODELAY` option.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn enable_nodelay(&self) -> &Self {
+        self.nodelay(true).await
+    }
+
+    /// Disables the `TCP_NODELAY` option.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn disable_nodelay(&self) -> &Self {
+        self.nodelay(false).await
+    }
+
+    /// Sets the `IP_TTL` option.
+    ///
+    /// # Arguments
+    ///
+    /// - `ttl` - The value for `IP_TTL`.
+    ///
+    /// # Returns
+    ///
+    /// - `&Self` - A reference to `Self` for method chaining.
+    pub async fn ttl(&self, ttl: u32) -> &Self {
+        self.write().await.ttl = Some(ttl);
+        self
+    }
+}
+
+/// Implementation block for `ServerConfigData`.
+impl ServerConfigData {
+    /// Gets the host address.
+    ///
+    /// # Returns
+    ///
+    /// - `&String` - Reference to the host address.
+    pub fn get_host(&self) -> &String {
+        &self.host
+    }
+
+    /// Gets the port number.
+    ///
+    /// # Returns
+    ///
+    /// - `u16` - The port number.
+    pub fn get_port(&self) -> u16 {
+        self.port
+    }
+
+    /// Gets the buffer size.
+    ///
+    /// # Returns
+    ///
+    /// - `usize` - The buffer size in bytes.
+    pub fn get_buffer_size(&self) -> usize {
+        self.buffer_size
+    }
+
+    /// Gets the `TCP_NODELAY` option.
+    ///
+    /// # Returns
+    ///
+    /// - `Option<bool>` - The `TCP_NODELAY` value if set.
+    pub fn get_nodelay(&self) -> Option<bool> {
+        self.nodelay
+    }
+
+    /// Gets the `IP_TTL` option.
+    ///
+    /// # Returns
+    ///
+    /// - `Option<u32>` - The `IP_TTL` value if set.
+    pub fn get_ttl(&self) -> Option<u32> {
+        self.ttl
+    }
+
+    /// Sets the host address.
+    ///
+    /// # Arguments
+    ///
+    /// - `impl AsRef<str>` - The host address to set.
+    pub fn set_host<H>(&mut self, host: H)
+    where
+        H: AsRef<str>,
+    {
+        self.host = host.as_ref().to_owned();
+    }
+
+    /// Sets the port number.
+    ///
+    /// # Arguments
+    ///
+    /// - `u16` - The port number to set.
+    pub fn set_port(&mut self, port: u16) {
+        self.port = port;
+    }
+
+    /// Sets the buffer size.
+    ///
+    /// # Arguments
+    ///
+    /// - `usize` - The buffer size in bytes.
+    pub fn set_buffer_size(&mut self, size: usize) {
+        self.buffer_size = size;
+    }
+
+    /// Sets the `TCP_NODELAY` option.
+    ///
+    /// # Arguments
+    ///
+    /// - `Option<bool>` - The `TCP_NODELAY` value.
+    pub fn set_nodelay(&mut self, nodelay: Option<bool>) {
+        self.nodelay = nodelay;
+    }
+
+    /// Sets the `IP_TTL` option.
+    ///
+    /// # Arguments
+    ///
+    /// - `Option<u32>` - The `IP_TTL` value.
+    pub fn set_ttl(&mut self, ttl: Option<u32>) {
+        self.ttl = ttl;
+    }
+}