Document socket module

lib/internal/socket.rs

@@ -1,3 +1,5 @@
+//! Socket is wrapper around a low-level socket (for example a TcpStream from the standard library) that allows for sending a response from other threads.
+
 use std::{
     io::{self, Read, Write},
     net::{Shutdown, SocketAddr, TcpStream},
@@ -15,12 +17,20 @@ use crate::{
     trace,
 };
 
+/// A [`Stream`] that also implements [`Send`] and [`Sync`].
 pub type SocketStream = Box<dyn Stream + Send + Sync>;
 
+/// A trait that represents a socket.
+/// This is used to allow for custom socket implementations to be used, for example, to add support for TLS.
 pub trait Stream: Read + Write {
+    /// Get the peer address of the socket.
     fn peer_addr(&self) -> io::Result<SocketAddr>;
+    /// Clone the socket.
+    /// This is currently only used for websockets.
     fn try_clone(&self) -> io::Result<SocketStream>;
+    /// Shutdown the socket.
     fn shutdown(&self, shutdown: Shutdown) -> io::Result<()>;
+    /// Set the timeout of the socket, for both reading and writing.
     fn set_timeout(&self, duration: Option<Duration>) -> io::Result<()>;
 }
 

lib/lib.rs

@@ -16,7 +16,7 @@ mod consts {
 }
 
 pub mod internal;
-use internal::{encoding, handle, router};
+use internal::{encoding, router};
 
 #[macro_use]
 pub mod trace;

lib/proto/http/query.rs

@@ -135,10 +135,7 @@ impl Query {
                 continue;
             };
 
-            data.push(QueryParameter {
-                key: key.into(),
-                value: value.into(),
-            });
+            data.push(QueryParameter { key, value });
         }
 
         Query { inner: data }

lib/server.rs

@@ -35,6 +35,7 @@ pub struct Server<State: 'static + Send + Sync = ()> {
     /// Ip address to listen on.
     pub ip: IpAddr,
 
+    /// The event loop used to handle incoming connections.
     pub event_loop: Box<dyn EventLoop<State>>,
 
     /// Routes to handle.
@@ -173,6 +174,17 @@ impl<State: Send + Sync> Server<State> {
         self
     }
 
+    /// Change the server's event loop.
+    /// The default is [`TcpEventLoop`], which uses the standard library's built-in TCP listener.
+    ///
+    /// The [afire_tls](https://github.com/Basicprogrammer10/afire_tls) crate contains an event loop that uses rustls to handle TLS connections.
+    pub fn event_loop(self, event_loop: impl EventLoop<State> + 'static) -> Self {
+        Server {
+            event_loop: Box::new(event_loop),
+            ..self
+        }
+    }
+
     /// Add a new default header to the server.
     /// This will be added to every response if it is not already present.
     ///