feat: v2.3.0

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tcp-request"
-version = "2.2.10"
+version = "2.3.0"
 edition = "2024"
 authors = ["root@ltpp.vip"]
 license = "MIT"

src/common/const.rs

@@ -1,6 +1,17 @@
+/// Empty string constant.
 pub const EMPTY_STR: &str = "";
+
+/// Default web port number.
 pub const DEFAULT_WEB_PORT: usize = 80;
+
+/// Request split marker string.
 pub const SPLIT_REQUEST: &str = "\r\n\r\n";
+
+/// Request split marker bytes.
 pub const SPLIT_REQUEST_BYTES: &[u8] = SPLIT_REQUEST.as_bytes();
+
+/// Default buffer size for requests.
 pub const DEFAULT_BUFFER_SIZE: usize = 512_000;
+
+/// Default timeout value (maximum possible u64 value).
 pub const DEFAULT_TIMEOUT: u64 = u64::MAX;

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/lib.rs

@@ -1,3 +1,9 @@
+//! tcp-request
+//!
+//! A Rust library for sending raw TCP requests, with features
+//! for handling responses, managing redirects, and working
+//! with compressed data over TCP connections.
+
 #[cfg(test)]
 mod cfg;
 pub(crate) mod common;

src/request/config/impl.rs

@@ -1,6 +1,12 @@
 use crate::*;
 
+/// Default implementation for Config.
 impl Default for Config {
+    /// Creates a default configuration instance.
+    ///
+    /// # Returns
+    ///
+    /// - `Config` - A new Config instance with default values.
     fn default() -> Self {
         Self {
             timeout: DEFAULT_TIMEOUT,

src/request/config/struct.rs

@@ -1,9 +1,14 @@
 use crate::*;
 
+/// Configuration for TCP request settings.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct Config {
+    /// Target host address.
     pub(crate) host: String,
+    /// Target port number.
     pub(crate) port: usize,
+    /// Request timeout in seconds.
     pub(crate) timeout: u64,
+    /// Buffer size for data transfer.
     pub(crate) buffer_size: usize,
 }

src/request/error/enum.rs

@@ -1,10 +1,18 @@
+/// Error types for request operations.
 #[derive(Debug)]
 pub enum RequestError {
+    /// Invalid URL provided.
     InvalidUrl,
+    /// Failed to establish TCP connection.
     TcpStreamConnectError,
+    /// General request error.
     RequestError,
+    /// Error reading from connection.
     ReadConnectionError,
+    /// Failed to set read timeout.
     SetReadTimeoutError,
+    /// Failed to set write timeout.
     SetWriteTimeoutError,
+    /// Error reading response.
     ReadResponseError,
 }

src/request/error/impl.rs

@@ -1,8 +1,19 @@
 use crate::*;
 
+/// Standard error implementation for RequestError.
 impl StdError for RequestError {}
 
+/// Display formatting implementation for RequestError.
 impl Display for RequestError {
+    /// Formats the error for display.
+    ///
+    /// # Arguments
+    ///
+    /// - `&mut fmt::Formatter<'_>` - The formatter to write to.
+    ///
+    /// # Returns
+    ///
+    /// - `fmt::Result` - The result of the formatting operation.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::InvalidUrl => write!(f, "Invalid URL"),

src/request/request/impl.rs

@@ -1,6 +1,17 @@
 use crate::*;
 
+/// Implementation of TCP request operations.
 impl TcpRequest {
+    /// Sends data through the TCP connection.
+    ///
+    /// # Arguments
+    ///
+    /// - `&mut TcpStream` - The TCP stream to send data through.
+    /// - `&[u8]` - The data to be sent.
+    ///
+    /// # Returns
+    ///
+    /// - `Result<BoxResponseTrait, RequestError>` - The response or error.
     fn send_request(
         &mut self,
         stream: &mut TcpStream,
@@ -15,6 +26,15 @@ impl TcpRequest {
         self.read_response(stream)
     }
 
+    /// Reads response from the TCP connection.
+    ///
+    /// # Arguments
+    ///
+    /// - `&mut TcpStream` - The TCP stream to read from.
+    ///
+    /// # Returns
+    ///
+    /// - `Result<BoxResponseTrait, RequestError>` - The response or error.
     fn read_response(&mut self, stream: &mut TcpStream) -> Result<BoxResponseTrait, RequestError> {
         let cfg_buffer_size: usize = self
             .config
@@ -36,6 +56,16 @@ impl TcpRequest {
         ));
     }
 
+    /// Establishes a TCP connection to the specified host and port.
+    ///
+    /// # Arguments
+    ///
+    /// - `String` - The host address to connect to.
+    /// - `usize` - The port number to connect to.
+    ///
+    /// # Returns
+    ///
+    /// - `Result<TcpStream, RequestError>` - The TCP stream or error.
     fn get_connection_stream(&self, host: String, port: usize) -> Result<TcpStream, RequestError> {
         let host_port: (String, u16) = (host.clone(), port as u16);
         let cfg_timeout: u64 = self
@@ -56,9 +86,19 @@ impl TcpRequest {
     }
 }
 
+/// RequestTrait implementation for TcpRequest.
 impl RequestTrait for TcpRequest {
     type RequestResult = RequestResult;
 
+    /// Sends data through the TCP request.
+    ///
+    /// # Arguments
+    ///
+    /// - `&[u8]` - The data to be sent.
+    ///
+    /// # Returns
+    ///
+    /// - `RequestResult` - The result of the send operation.
     fn send(&mut self, data: &[u8]) -> Self::RequestResult {
         let cfg_timeout: Config = self
             .config
@@ -74,7 +114,13 @@ impl RequestTrait for TcpRequest {
     }
 }
 
+/// Default implementation for TcpRequest.
 impl Default for TcpRequest {
+    /// Creates a default TcpRequest instance.
+    ///
+    /// # Returns
+    ///
+    /// - `TcpRequest` - A new TcpRequest instance with default configuration.
     fn default() -> Self {
         Self {
             config: Arc::new(RwLock::new(Config::default())),

src/request/request/struct.rs

@@ -1,7 +1,10 @@
 use crate::*;
 
+/// TCP request structure containing configuration and response data.
 #[derive(Debug, Clone)]
 pub struct TcpRequest {
+    /// Thread-safe configuration for the request.
     pub(crate) config: ArcRwLock<Config>,
+    /// Thread-safe binary response storage.
     pub(crate) response: ArcRwLock<TcpResponseBinary>,
 }