Small tweaks

- Some code clean up
- Prepare for publishing

Cargo.toml

@@ -1,17 +1,25 @@
 
 [package]
 name = "lazuli"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2021"
+publish = true
+
 
 [workspace]
 members = ["lazuli_core", "lazuli_derive"]
 
 [workspace.package]
 version = "0.1.0"
+authors = ["quackitsquinn"]
+license = "GPL-3.0"
+readme = "README.md"
+repository = "https://github.com/quackitsquinn/lazuli"
+description = "A socket library for consistent, quick, and easy data transfer"
+keywords = ["socket", "networking", "data transfer", "tcp", "lazuli"]
 
 
 [dependencies]
-lazuli_core = { path = "lazuli_core" }
-lazuli_derive = { path = "lazuli_derive" }
+lazuli_core = { path = "lazuli_core", version = "0.1.0"}
+lazuli_derive = { path = "lazuli_derive", version = "0.1.0"}
 

examples/hello_world.rs

@@ -7,7 +7,7 @@ const ADDRESS: SocketAddr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST
 pub fn main() {
     // Initialize the server and client. The server will accept a connection from the client.
     let mut server = Server::new(ADDRESS).unwrap();
-    let mut client = Client::new(ADDRESS).unwrap();
+    let mut client = Client::connect(ADDRESS).unwrap();
 
     // Accept the connection from the client. This returns a Client object that can be used to communicate with the client.
     // The client object is wrapped in an Arc<Mutex<Client>> to allow for thread-safe access.

lazuli_core/src/client/client.rs

@@ -102,7 +102,7 @@ impl Client {
         T: Sendable + 'static,
     {
         // SAFETY: This is safe because the stream is connected to a StreamConnector, which is guaranteed to be valid.
-        let stream: Stream<T> = unsafe { Stream::new() };
+        let stream: Stream<T> = Stream::new();
         let info = StreamConnector::new(&stream);
         self.streams
             .lock()
@@ -141,6 +141,26 @@ impl Client {
     }
 }
 
+impl Debug for Client {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Client")
+            .field("peer_addr", &self.peer_addr())
+            .field("is_connected", &self.is_connected())
+            .field(
+                "streams",
+                // This line pasta converts the array of StreamConnector into an array of &str
+                &self
+                    .streams
+                    .lock()
+                    .unwrap()
+                    .values()
+                    .map(|x| x.type_name())
+                    .collect::<Vec<&str>>(),
+            )
+            .finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::vec;
@@ -249,7 +269,7 @@ mod tests {
 
     #[test]
     fn test_stream_data_struct() {
-        let mut stream: Stream<TestStruct> = unsafe { Stream::new() };
+        let mut stream: Stream<TestStruct> = Stream::new();
         let mut data = StreamConnector::new(&stream);
         unsafe {
             data.push_raw(TestStruct { a: 30, b: 40 }.send().into())

lazuli_core/src/client/connector.rs

@@ -1,13 +1,14 @@
 //! Contains the StreamConnector struct, which allows for the pushing of data into a Stream.
 
 use std::{
+    fmt::Debug,
     io::Read,
     mem::{self, ManuallyDrop},
 };
 
 use log::trace;
 
-use crate::{stream::Stream, ArcMutex, Result, PacketHeader, Sendable, UnknownType};
+use crate::{stream::Stream, ArcMutex, PacketHeader, Result, Sendable, UnknownType};
 
 /// A single byte type that is used to store the raw data.
 #[repr(transparent)]
@@ -22,6 +23,7 @@ pub struct StreamConnector {
     size: usize,
     grew: ArcMutex<usize>,
     conversion_fn: fn(&mut dyn Read) -> Result<Box<[u8]>>,
+    type_name: &'static str,
 }
 
 impl StreamConnector {
@@ -33,6 +35,7 @@ impl StreamConnector {
             size: mem::size_of::<T>(),
             grew: stream.get_grow_by(),
             conversion_fn: T::as_conversion_fn(),
+            type_name: std::any::type_name::<T>(),
         }
     }
     /// Pushes data to the stream.
@@ -88,6 +91,19 @@ impl StreamConnector {
         unsafe { self.push_raw(converted)? };
         Ok(())
     }
+    /// Returns the type name of the stream. This is mainly used for the debug implementation.
+    pub fn type_name(&self) -> &'static str {
+        self.type_name
+    }
+}
+
+impl Debug for StreamConnector {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StreamConnector")
+            .field("type_name", &self.type_name)
+            .field("size", &self.size)
+            .finish()
+    }
 }
 
 /// Everything in StreamConnector is behind a mutex, besides the size. The size should never change.

lazuli_core/src/client/server.rs

@@ -104,6 +104,7 @@ mod test {
         let mut client2 = make_server_client_pair(&mut server);
         let mut str_stream_1 = client1.0.stream::<String>();
         let mut str_stream_2 = client2.0.stream::<String>();
+        println!("{:#?}", client1.0);
         server.broadcast(&"Hello, world!".to_owned())?;
         client1.0.recv()?;
         client2.0.recv()?;