LibCore: Add a basic wrapper for adapting AK::Stream to Core::Stream

Userland/Libraries/LibCore/Stream.cpp

@@ -714,4 +714,72 @@ ErrorOr<int> LocalSocket::release_fd()
     return fd;
 }
 
+WrappedAKInputStream::WrappedAKInputStream(NonnullOwnPtr<InputStream> stream)
+    : m_stream(move(stream))
+{
+}
+
+ErrorOr<Bytes> WrappedAKInputStream::read(Bytes bytes)
+{
+    auto bytes_read = m_stream->read(bytes);
+
+    if (m_stream->has_any_error())
+        return Error::from_string_literal("Underlying InputStream indicated an error");
+
+    return bytes.slice(0, bytes_read);
+}
+
+ErrorOr<size_t> WrappedAKInputStream::write(ReadonlyBytes)
+{
+    VERIFY_NOT_REACHED();
+}
+
+bool WrappedAKInputStream::is_eof() const
+{
+    return m_stream->unreliable_eof();
+}
+
+bool WrappedAKInputStream::is_open() const
+{
+    return true;
+}
+
+void WrappedAKInputStream::close()
+{
+}
+
+WrappedAKOutputStream::WrappedAKOutputStream(NonnullOwnPtr<OutputStream> stream)
+    : m_stream(move(stream))
+{
+}
+
+ErrorOr<Bytes> WrappedAKOutputStream::read(Bytes)
+{
+    VERIFY_NOT_REACHED();
+}
+
+ErrorOr<size_t> WrappedAKOutputStream::write(ReadonlyBytes bytes)
+{
+    auto bytes_written = m_stream->write(bytes);
+
+    if (m_stream->has_any_error())
+        return Error::from_string_literal("Underlying OutputStream indicated an error");
+
+    return bytes_written;
+}
+
+bool WrappedAKOutputStream::is_eof() const
+{
+    VERIFY_NOT_REACHED();
+}
+
+bool WrappedAKOutputStream::is_open() const
+{
+    return true;
+}
+
+void WrappedAKOutputStream::close()
+{
+}
+
 }

Userland/Libraries/LibCore/Stream.h

@@ -968,4 +968,32 @@ private:
 using ReusableTCPSocket = BasicReusableSocket<TCPSocket>;
 using ReusableUDPSocket = BasicReusableSocket<UDPSocket>;
 
+// Note: This is only a temporary hack, to break up the task of moving away from AK::Stream into smaller parts.
+class WrappedAKInputStream final : public Stream {
+public:
+    WrappedAKInputStream(NonnullOwnPtr<InputStream> stream);
+    virtual ErrorOr<Bytes> read(Bytes) override;
+    virtual ErrorOr<size_t> write(ReadonlyBytes) override;
+    virtual bool is_eof() const override;
+    virtual bool is_open() const override;
+    virtual void close() override;
+
+private:
+    NonnullOwnPtr<InputStream> m_stream;
+};
+
+// Note: This is only a temporary hack, to break up the task of moving away from AK::Stream into smaller parts.
+class WrappedAKOutputStream final : public Stream {
+public:
+    WrappedAKOutputStream(NonnullOwnPtr<OutputStream> stream);
+    virtual ErrorOr<Bytes> read(Bytes) override;
+    virtual ErrorOr<size_t> write(ReadonlyBytes) override;
+    virtual bool is_eof() const override;
+    virtual bool is_open() const override;
+    virtual void close() override;
+
+private:
+    NonnullOwnPtr<OutputStream> m_stream;
+};
+
 }