rust wrappers

Author: mikea

kj-rs/io/lib.rs

@@ -461,16 +461,105 @@ impl<T: AsyncOutputStream + Unpin> futures::io::AsyncWrite for AsyncWriteAdapter
 #[allow(clippy::needless_lifetimes)]
 pub mod ffi {
 
+    // Rust opaque types that can be used from C++
+    extern "Rust" {
+        /// Opaque Rust type implementing AsyncInputStream trait
+        type RustAsyncInputStream;
+        
+        /// Opaque Rust type implementing AsyncOutputStream trait
+        type RustAsyncOutputStream;
+        
+        /// Opaque Rust type implementing AsyncIoStream trait
+        type RustAsyncIoStream;
+
+        // RustAsyncInputStream methods
+        async unsafe fn try_read<'a>(
+            self: &'a mut RustAsyncInputStream,
+            buffer: &'a mut [u8],
+            min_bytes: usize,
+        ) -> Result<usize>;
+
+        fn try_get_length(self: &RustAsyncInputStream) -> u64; // Return 0 if unknown
+
+        async unsafe fn pump_to<'a>(
+            self: &'a mut RustAsyncInputStream,
+            output: &'a mut RustAsyncOutputStream,
+            amount: u64,
+        ) -> Result<u64>;
+
+        // RustAsyncOutputStream methods
+        async unsafe fn write<'a>(
+            self: &'a mut RustAsyncOutputStream, 
+            buffer: &'a [u8]
+        ) -> Result<()>;
+
+        async unsafe fn write_vectored<'a>(
+            self: &'a mut RustAsyncOutputStream,
+            pieces: &'a [&'a [u8]],
+        ) -> Result<()>;
+
+        async unsafe fn try_pump_from<'a>(
+            self: &'a mut RustAsyncOutputStream,
+            input: &'a mut RustAsyncInputStream,
+            amount: u64,
+        ) -> Result<u64>; // Returns 0 if not supported
+
+        async unsafe fn when_write_disconnected<'a>(
+            self: &'a mut RustAsyncOutputStream
+        ) -> Result<()>;
+
+        // RustAsyncIoStream methods - inherited from AsyncInputStream
+        async unsafe fn try_read<'a>(
+            self: &'a mut RustAsyncIoStream,
+            buffer: &'a mut [u8],
+            min_bytes: usize,
+        ) -> Result<usize>;
+
+        fn try_get_length(self: &RustAsyncIoStream) -> u64;
+
+        async unsafe fn pump_to<'a>(
+            self: &'a mut RustAsyncIoStream,
+            output: &'a mut RustAsyncOutputStream,
+            amount: u64,
+        ) -> Result<u64>;
+
+        // RustAsyncIoStream methods - inherited from AsyncOutputStream
+        async unsafe fn write<'a>(
+            self: &'a mut RustAsyncIoStream, 
+            buffer: &'a [u8]
+        ) -> Result<()>;
+
+        async unsafe fn write_vectored<'a>(
+            self: &'a mut RustAsyncIoStream,
+            pieces: &'a [&'a [u8]],
+        ) -> Result<()>;
+
+        async unsafe fn try_pump_from<'a>(
+            self: &'a mut RustAsyncIoStream,
+            input: &'a mut RustAsyncInputStream,
+            amount: u64,
+        ) -> Result<u64>;
+
+        async unsafe fn when_write_disconnected<'a>(
+            self: &'a mut RustAsyncIoStream
+        ) -> Result<()>;
+
+        // RustAsyncIoStream methods - specific to IoStream
+        async unsafe fn shutdown_write<'a>(self: &'a mut RustAsyncIoStream) -> Result<()>;
+
+        fn abort_read(self: &mut RustAsyncIoStream);
+    }
+
     unsafe extern "C++" {
         include!("kj-rs/io/bridge.h");
 
-        /// Opaque C++ type representing CxxAsyncInputStream
+        /// Opaque C++ type representing kj::AsyncInputStream
         type CxxAsyncInputStream;
 
-        /// Opaque C++ type representing CxxAsyncOutputStream  
+        /// Opaque C++ type representing kj::AsyncOutputStream  
         type CxxAsyncOutputStream;
 
-        /// Opaque C++ type representing CxxAsyncIoStream
+        /// Opaque C++ type representing kj::AsyncIoStream
         type CxxAsyncIoStream;
 
         // CxxAsyncInputStream methods
@@ -544,12 +633,8 @@ pub mod ffi {
 
         fn abort_read(self: Pin<&mut CxxAsyncIoStream>);
     }
-
-    impl UniquePtr<CxxAsyncInputStream> {}
 }
 
-// Rust wrapper types that implement the AsyncInputStream, AsyncOutputStream, and AsyncIoStream traits
-
 /// Helper function to convert `cxx::Exception` to `std::io::Error`
 #[must_use]
 #[allow(clippy::needless_pass_by_value)]
@@ -725,3 +810,119 @@ impl<'a> AsyncIoStream for CxxAsyncIoStream<'a> {
         self.inner.as_mut().abort_read();
     }
 }
+
+// Rust opaque types for use from C++
+
+/// Opaque Rust type that can hold any AsyncInputStream implementation
+pub struct RustAsyncInputStream {
+    inner: Box<dyn AsyncInputStream + Send>,
+}
+
+impl RustAsyncInputStream {
+    pub fn new<T: AsyncInputStream + Send + 'static>(stream: T) -> Self {
+        Self {
+            inner: Box::new(stream),
+        }
+    }
+
+    // FFI method implementations
+    pub async fn try_read(&mut self, buffer: &mut [u8], min_bytes: usize) -> Result<usize> {
+        self.inner.try_read(buffer, min_bytes).await
+    }
+
+    pub fn try_get_length(&self) -> u64 {
+        self.inner.try_get_length().unwrap_or(0)
+    }
+
+    pub async fn pump_to(&mut self, output: &mut RustAsyncOutputStream, amount: u64) -> Result<u64> {
+        self.inner.pump_to(&mut *output.inner, amount).await
+    }
+}
+
+/// Opaque Rust type that can hold any AsyncOutputStream implementation
+pub struct RustAsyncOutputStream {
+    inner: Box<dyn AsyncOutputStream + Send>,
+}
+
+impl RustAsyncOutputStream {
+    pub fn new<T: AsyncOutputStream + Send + 'static>(stream: T) -> Self {
+        Self {
+            inner: Box::new(stream),
+        }
+    }
+
+    // FFI method implementations
+    pub async fn write(&mut self, buffer: &[u8]) -> Result<()> {
+        self.inner.write(buffer).await
+    }
+
+    pub async fn write_vectored(&mut self, pieces: &[&[u8]]) -> Result<()> {
+        self.inner.write_vectored(pieces).await
+    }
+
+    pub async fn try_pump_from(&mut self, input: &mut RustAsyncInputStream, amount: u64) -> Result<u64> {
+        match self.inner.try_pump_from(&mut *input.inner, amount).await {
+            Some(result) => result,
+            None => Ok(0), // Return 0 to indicate no optimization available
+        }
+    }
+
+    pub async fn when_write_disconnected(&mut self) -> Result<()> {
+        self.inner.when_write_disconnected().await
+    }
+}
+
+/// Opaque Rust type that can hold any AsyncIoStream implementation
+pub struct RustAsyncIoStream {
+    inner: Box<dyn AsyncIoStream + Send>,
+}
+
+impl RustAsyncIoStream {
+    pub fn new<T: AsyncIoStream + Send + 'static>(stream: T) -> Self {
+        Self {
+            inner: Box::new(stream),
+        }
+    }
+
+    // FFI method implementations - AsyncInputStream part
+    pub async fn try_read(&mut self, buffer: &mut [u8], min_bytes: usize) -> Result<usize> {
+        self.inner.try_read(buffer, min_bytes).await
+    }
+
+    pub fn try_get_length(&self) -> u64 {
+        self.inner.try_get_length().unwrap_or(0)
+    }
+
+    pub async fn pump_to(&mut self, output: &mut RustAsyncOutputStream, amount: u64) -> Result<u64> {
+        self.inner.pump_to(&mut *output.inner, amount).await
+    }
+
+    // FFI method implementations - AsyncOutputStream part
+    pub async fn write(&mut self, buffer: &[u8]) -> Result<()> {
+        self.inner.write(buffer).await
+    }
+
+    pub async fn write_vectored(&mut self, pieces: &[&[u8]]) -> Result<()> {
+        self.inner.write_vectored(pieces).await
+    }
+
+    pub async fn try_pump_from(&mut self, input: &mut RustAsyncInputStream, amount: u64) -> Result<u64> {
+        match self.inner.try_pump_from(&mut *input.inner, amount).await {
+            Some(result) => result,
+            None => Ok(0), // Return 0 to indicate no optimization available
+        }
+    }
+
+    pub async fn when_write_disconnected(&mut self) -> Result<()> {
+        self.inner.when_write_disconnected().await
+    }
+
+    // FFI method implementations - AsyncIoStream specific
+    pub async fn shutdown_write(&mut self) -> Result<()> {
+        self.inner.shutdown_write().await
+    }
+
+    pub fn abort_read(&mut self) {
+        self.inner.abort_read();
+    }
+}