calling rust works

Author: mikea

kj-rs/io/bridge.c++

@@ -8,6 +8,7 @@
 using namespace kj_rs;
 
 namespace kj_rs_io {
+
 namespace ffi {
 
 CxxAsyncInputStream::CxxAsyncInputStream(kj::Own<kj::AsyncInputStream> stream)
@@ -129,4 +130,5 @@ void CxxAsyncIoStream::abort_read() {
 }
 
 }  // namespace ffi
+
 }  // namespace kj_rs_io

kj-rs/io/bridge.h

@@ -1,13 +1,20 @@
 #pragma once
 
+#include "kj-rs/convert.h"
+#include "kj-rs/kj-rs.h"
+
 #include <rust/cxx.h>
 
 #include <kj/async-io.h>
 #include <kj/memory.h>
 
+#include <cstdint>
+
+using namespace kj_rs;
+
 namespace kj_rs_io {
 
-// Forward declarations  
+// Forward declarations
 namespace ffi {
 struct CxxAsyncOutputStream;
 
@@ -64,71 +71,109 @@ struct CxxAsyncIoStream {
   void abort_read();
 };
 
-} // namespace ffi
-
-// C++ classes that wrap Rust FFI types and implement KJ interfaces
-namespace ffi {
-
-// Forward declarations for Rust FFI types  
-struct RustAsyncInputStream;
-struct RustAsyncOutputStream; 
-struct RustAsyncIoStream;
-
-// C++ classes that wrap Rust FFI types and implement KJ interfaces
+}  // namespace ffi
 
-class RustInputStreamWrapper : public kj::AsyncInputStream {
-public:
-  explicit RustInputStreamWrapper(::rust::Box<RustAsyncInputStream> rust_stream);
-  virtual ~RustInputStreamWrapper() = default;
+template <typename T>
+class RustAsyncInputStream: public kj::AsyncInputStream {
+ public:
+  explicit RustAsyncInputStream(T&& impl): impl(kj::mv(impl)) {}
+  virtual ~RustAsyncInputStream() = default;
 
   // kj::AsyncInputStream interface
-  kj::Promise<size_t> tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
-  kj::Maybe<uint64_t> tryGetLength() override;
-  kj::Promise<uint64_t> pumpTo(kj::AsyncOutputStream& output, uint64_t amount) override;
-
-private:
-  ::rust::Box<RustAsyncInputStream> rust_stream_;
+  kj::Promise<size_t> tryRead(void* buffer, size_t minBytes, size_t maxBytes) override {
+    return impl->try_read(
+        kj::arrayPtr(reinterpret_cast<uint8_t*>(buffer), maxBytes).as<RustMutable>(), minBytes);
+  }
+
+  kj::Maybe<uint64_t> tryGetLength() override {
+    // todo
+    return kj::none;
+  }
+
+  // kj::Promise<uint64_t> pumpTo(kj::AsyncOutputStream& output, uint64_t amount) override {
+  //   return impl->pumpTo(output, amount);
+  // }
+
+ private:
+  T impl;
 };
 
-class RustOutputStreamWrapper : public kj::AsyncOutputStream {
-public:
-  explicit RustOutputStreamWrapper(::rust::Box<RustAsyncOutputStream> rust_stream);
-  virtual ~RustOutputStreamWrapper() = default;
+template <typename T>
+class RustAsyncOutputStream: public kj::AsyncOutputStream {
+ public:
+  explicit RustAsyncOutputStream(T&& impl): impl(kj::mv(impl)) {}
+  virtual ~RustAsyncOutputStream() = default;
 
   // kj::AsyncOutputStream interface
-  kj::Promise<void> write(kj::ArrayPtr<const kj::byte> buffer) override;
-  kj::Promise<void> write(kj::ArrayPtr<const kj::ArrayPtr<const kj::byte>> pieces) override;
-  kj::Maybe<kj::Promise<uint64_t>> tryPumpFrom(kj::AsyncInputStream& input, uint64_t amount) override;
-  kj::Promise<void> whenWriteDisconnected() override;
+  kj::Promise<void> write(kj::ArrayPtr<const kj::byte> buffer) override {
+    return impl->write(buffer);
+  }
+
+  kj::Promise<void> write(kj::ArrayPtr<const kj::ArrayPtr<const kj::byte>> pieces) override {
+    return impl->write(pieces);
+  }
 
-private:
-  ::rust::Box<RustAsyncOutputStream> rust_stream_;
+  kj::Maybe<kj::Promise<uint64_t>> tryPumpFrom(
+      kj::AsyncInputStream& input, uint64_t amount) override {
+    return impl->tryPumpFrom(input, amount);
+  }
+
+  kj::Promise<void> whenWriteDisconnected() override {
+    return impl->whenWriteDisconnected();
+  }
+
+ private:
+  T impl;
 };
 
-class RustIoStreamWrapper : public kj::AsyncIoStream {
-public:
-  explicit RustIoStreamWrapper(::rust::Box<RustAsyncIoStream> rust_stream);
-  virtual ~RustIoStreamWrapper() = default;
+template <typename T>
+class RustAsyncIoStream: public kj::AsyncIoStream {
+ public:
+  explicit RustAsyncIoStream(T&& impl): impl(kj::mv(impl)) {}
+  virtual ~RustAsyncIoStream() = default;
 
   // kj::AsyncInputStream interface
-  kj::Promise<size_t> tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
-  kj::Maybe<uint64_t> tryGetLength() override;
-  kj::Promise<uint64_t> pumpTo(kj::AsyncOutputStream& output, uint64_t amount) override;
+  kj::Promise<size_t> tryRead(void* buffer, size_t minBytes, size_t maxBytes) override {
+    return impl->tryRead(buffer, minBytes, maxBytes);
+  }
+
+  kj::Maybe<uint64_t> tryGetLength() override {
+    return impl->tryGetLength();
+  }
+
+  kj::Promise<uint64_t> pumpTo(kj::AsyncOutputStream& output, uint64_t amount) override {
+    return impl->pumpTo(output, amount);
+  }
 
   // kj::AsyncOutputStream interface
-  kj::Promise<void> write(kj::ArrayPtr<const kj::byte> buffer) override;
-  kj::Promise<void> write(kj::ArrayPtr<const kj::ArrayPtr<const kj::byte>> pieces) override;
-  kj::Maybe<kj::Promise<uint64_t>> tryPumpFrom(kj::AsyncInputStream& input, uint64_t amount) override;
-  kj::Promise<void> whenWriteDisconnected() override;
+  kj::Promise<void> write(kj::ArrayPtr<const kj::byte> buffer) override {
+    return impl->write(buffer);
+  }
+
+  kj::Promise<void> write(kj::ArrayPtr<const kj::ArrayPtr<const kj::byte>> pieces) override {
+    return impl->write(pieces);
+  }
+
+  kj::Maybe<kj::Promise<uint64_t>> tryPumpFrom(
+      kj::AsyncInputStream& input, uint64_t amount) override {
+    return impl->tryPumpFrom(input, amount);
+  }
+
+  kj::Promise<void> whenWriteDisconnected() override {
+    return impl->whenWriteDisconnected();
+  }
 
   // kj::AsyncIoStream interface
-  void shutdownWrite() override;
-  void abortRead() override;
+  void shutdownWrite() override {
+    impl->shutdownWrite();
+  }
 
-private:
-  ::rust::Box<RustAsyncIoStream> rust_stream_;
-};
+  void abortRead() override {
+    impl->abortRead();
+  }
 
-}  // namespace ffi
+ private:
+  T impl;
+};
 
 }  // namespace kj_rs_io