feat: v1.0.4

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "udp"
-version = "1.0.3"
+version = "1.0.4"
 edition = "2024"
 authors = ["root@ltpp.vip"]
 license = "MIT"
@@ -18,7 +18,6 @@ exclude = [
 ]
 
 [dependencies]
-lombok-macros = "1.12.0"
 tokio = { version = "1.45.1", features = ["full"] }
 
 [profile.dev]

src/config/struct.rs

@@ -1,9 +1,9 @@
 use crate::*;
 
-#[derive(Clone, Data)]
+#[derive(Clone)]
 pub struct ServerConfig {
-    pub(super) host: String,
-    pub(super) port: usize,
-    pub(super) buffer_size: usize,
-    pub(super) error_handle: ArcErrorHandle,
+    pub(crate) host: String,
+    pub(crate) port: usize,
+    pub(crate) buffer_size: usize,
+    pub(crate) error_handle: ArcErrorHandle,
 }

src/context/impl.rs

@@ -30,19 +30,19 @@ impl Context {
     }
 
     pub async fn get_request(&self) -> Request {
-        self.get().await.get_request().clone()
+        self.get().await.request.clone()
     }
 
     pub async fn get_response(&self) -> Response {
-        self.get().await.get_response().clone()
+        self.get().await.response.clone()
     }
 
     pub async fn get_socket(&self) -> OptionArcRwLockUdpSocket {
-        self.get().await.get_socket().clone()
+        self.get().await.socket.clone()
     }
 
     pub async fn get_socket_addr(&self) -> OptionSocketAddr {
-        self.get().await.get_socket_addr().clone()
+        self.get().await.socket_addr.clone()
     }
 
     pub async fn get_socket_addr_or_default(&self) -> SocketAddr {
@@ -80,9 +80,7 @@ impl Context {
     }
 
     pub(super) async fn set_response<T: Into<ResponseData>>(&self, data: T) -> &Self {
-        self.get_write_lock()
-            .await
-            .set_response(Response::from(data));
+        self.get_write_lock().await.response = Response::from(data);
         self
     }
 
@@ -104,27 +102,27 @@ impl Context {
     ) -> &Self {
         self.get_write_lock()
             .await
-            .get_mut_data()
+            .data
             .insert(key.to_owned(), Arc::new(value.clone()));
         self
     }
 
     pub async fn get_data_value<T: Any + Send + Sync + Clone>(&self, key: &str) -> Option<T> {
         self.get_read_lock()
             .await
-            .get_data()
+            .data
             .get(key)
             .and_then(|arc| arc.downcast_ref::<T>())
             .cloned()
     }
 
     pub async fn remove_data_value(&self, key: &str) -> &Self {
-        self.get_write_lock().await.get_mut_data().remove(key);
+        self.get_write_lock().await.data.remove(key);
         self
     }
 
     pub async fn clear_data(&self) -> &Self {
-        self.get_write_lock().await.get_mut_data().clear();
+        self.get_write_lock().await.data.clear();
         self
     }
 }

src/context/struct.rs

@@ -1,12 +1,12 @@
 use crate::*;
 
-#[derive(Clone, Data)]
+#[derive(Clone)]
 pub struct InnerContext {
-    pub(super) socket: OptionArcRwLockUdpSocket,
-    pub(super) request: Request,
-    pub(super) response: Response,
-    pub(super) socket_addr: OptionSocketAddr,
-    pub(super) data: HashMapArcAnySendSync,
+    pub(crate) socket: OptionArcRwLockUdpSocket,
+    pub(crate) request: Request,
+    pub(crate) response: Response,
+    pub(crate) socket_addr: OptionSocketAddr,
+    pub(crate) data: HashMapArcAnySendSync,
 }
 
 #[derive(Clone)]

src/lib.rs

@@ -21,7 +21,6 @@ pub use tokio;
 
 pub(crate) use common::*;
 pub(crate) use handler::*;
-pub(crate) use lombok_macros::*;
 
 pub(crate) use std::{
     any::Any,

src/server/impl.rs

@@ -18,28 +18,25 @@ impl Server {
     where
         T: Into<String>,
     {
-        self.get_config().write().await.set_host(host.into());
+        self.config.write().await.host = host.into();
         self
     }
 
     pub async fn port(&mut self, port: usize) -> &mut Self {
-        self.get_config().write().await.set_port(port);
+        self.config.write().await.port = port;
         self
     }
 
     pub async fn buffer(&mut self, buffer_size: usize) -> &mut Self {
-        self.get_config().write().await.set_buffer_size(buffer_size);
+        self.config.write().await.buffer_size = buffer_size;
         self
     }
 
     pub async fn error_handle<F>(&self, func: F) -> &Self
     where
         F: ErrorHandle + Send + Sync + 'static,
     {
-        self.get_config()
-            .write()
-            .await
-            .set_error_handle(Arc::new(func));
+        self.config.write().await.error_handle = Arc::new(func);
         self
     }
 
@@ -57,28 +54,28 @@ impl Server {
 
     pub async fn run(&mut self) {
         self.init().await;
-        let config: ServerConfig = self.get_config().read().await.clone();
-        let host: String = config.get_host().to_owned();
-        let port: usize = *config.get_port();
+        let config: ServerConfig = self.config.read().await.clone();
+        let host: String = config.host.clone();
+        let port: usize = config.port;
         let addr: String = format!("{}{}{}", host, COLON_SPACE_SYMBOL, port);
         let socket: UdpSocket = UdpSocket::bind(&addr)
             .await
             .map_err(|e| ServerError::TcpBindError(e.to_string()))
             .unwrap();
         let socket_arc_lock: ArcRwLockUdpSocket = ArcRwLockUdpSocket::from_socket(socket);
         loop {
-            let mut buf: Vec<u8> = vec![0u8; *config.get_buffer_size()];
+            let mut buf: Vec<u8> = vec![0u8; config.buffer_size];
             let socket_arc_lock: ArcRwLockUdpSocket = socket_arc_lock.clone();
             let socket_lock: RwLockReadGuardUdpSocket = socket_arc_lock.get_read_lock().await;
             let (data_len, client_addr) = socket_lock.recv_from(&mut buf).await.unwrap();
-            let func_list_arc_lock: ArcRwLockVecFuncBox = Arc::clone(self.get_func_list());
+            let func_list_arc_lock: ArcRwLockVecFuncBox = Arc::clone(&self.func_list);
             let socket_clone: ArcRwLockUdpSocket = socket_arc_lock.clone();
             let handle_request = move || async move {
                 let request: Vec<u8> = buf[..data_len].to_vec();
                 let mut ctx: InnerContext = InnerContext::new();
-                ctx.set_socket(Some(socket_clone))
-                    .set_socket_addr(Some(client_addr))
-                    .set_request(request);
+                ctx.socket = Some(socket_clone);
+                ctx.socket_addr = Some(client_addr);
+                ctx.request = request;
                 let ctx: Context = Context::from_inner_context(ctx);
                 for func in func_list_arc_lock.read().await.iter() {
                     func(ctx.clone()).await;
@@ -89,8 +86,7 @@ impl Server {
     }
 
     async fn init_panic_hook(&self) {
-        let error_handle: ArcErrorHandle =
-            self.get_config().read().await.get_error_handle().clone();
+        let error_handle: ArcErrorHandle = self.config.read().await.error_handle.clone();
         set_hook(Box::new(move |err| {
             let data: String = err.to_string();
             error_handle(data);

src/server/struct.rs

@@ -1,6 +1,6 @@
 use crate::*;
 
-#[derive(Clone, Data)]
+#[derive(Clone)]
 pub struct Server {
     pub(super) config: ArcRwLockServerConfig,
     pub(super) func_list: ArcRwLockVecFuncBox,