v0.6.5 Fixes and IO extensions

- Fix stream being private
- Add tokio for IO extensions

Author: EasternGamer

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "hyper_byte"
-version = "0.6.0"
+version = "0.6.5"
 license = "MIT"
 authors = ["EasternGamer"]
 edition = "2024"
@@ -21,9 +21,12 @@ debug = true
 
 [dependencies]
 half = { version = "2.6.0", optional = true }
+tokio = { version = "1.46.1", features = ["io-util"],  optional = true }
 
 [features]
 half = ["dep:half"]
+tokio = ["dep:tokio"]
 
 [dev-dependencies]
-half = "2.6.0"
+half = "2.6.0"
+tokio = { version = "1.46.1", features = ["io-util"] }

Cargo.toml

@@ -0,0 +1 @@
+pub mod tcp_extensions;

src/extensions/mod.rs

@@ -0,0 +1,73 @@
+use crate::writers::traits::ByteWriter;
+#[cfg(feature = "tokio")]
+use tokio::io::AsyncReadExt;
+
+use std::io::Read;
+use std::mem::MaybeUninit;
+
+// Taken from nightly, to avoid nightly requirements
+#[inline(always)]
+const unsafe fn assume_init_mut<T>(array: &mut [MaybeUninit<T>]) -> &mut [T] {
+    // SAFETY: similar to safety notes for `slice_get_ref`, but we have a
+    // mutable reference which is also guaranteed to be valid for writes.
+    unsafe { &mut *(array as *mut [MaybeUninit<T>] as *mut [T]) }
+}
+
+
+pub trait HyperReadExactExt {
+    fn read_into_exact<T: ByteWriter>(
+        &mut self,
+        buffer: &mut T,
+        amount: usize,
+    ) -> Result<(), std::io::Error>;
+}
+
+impl<R: Read> HyperReadExactExt for R {
+    fn read_into_exact<T: ByteWriter>(
+        &mut self,
+        buffer: &mut T,
+        amount: usize,
+    ) -> Result<(), std::io::Error> {
+        let inner = buffer.as_mut_vec();
+        inner.reserve(amount);
+
+        let old_length = inner.len();
+        let reading_slice = unsafe { assume_init_mut(&mut inner.spare_capacity_mut()[..amount]) };
+
+        self.read_exact(reading_slice)?;
+
+        let new_length = amount + old_length;
+        unsafe { inner.set_len(new_length) }
+        Ok(())
+    }
+}
+
+#[cfg(feature = "tokio")]
+pub trait AsyncHyperReadExactExt {
+    async fn read_into_exact<T: ByteWriter>(
+        &mut self,
+        buffer: &mut T,
+        amount: usize,
+    ) -> Result<usize, std::io::Error>;
+}
+
+#[cfg(feature = "tokio")]
+impl<R: AsyncReadExt + Unpin> AsyncHyperReadExactExt for R {
+    async fn read_into_exact<T: ByteWriter>(
+        &mut self,
+        buffer: &mut T,
+        amount: usize,
+    ) -> Result<usize, std::io::Error> {
+        let inner = buffer.as_mut_vec();
+        inner.reserve(amount);
+
+        let length = inner.len();
+        let reading_slice = unsafe { assume_init_mut(&mut inner.spare_capacity_mut()[..amount]) };
+
+        let size_read = self.read_exact(reading_slice).await?;
+
+        let new_length = length + size_read;
+        unsafe { inner.set_len(new_length) };
+        Ok(size_read)
+    }
+}

src/extensions/tcp_extensions.rs

@@ -2,7 +2,8 @@ pub mod reader;
 pub mod readers;
 pub mod writer;
 pub mod writers;
-mod hyper_stream;
+pub mod hyper_stream;
+pub mod extensions;
 
 #[cfg(feature = "half")]
 use half::f16;