removed Buffer

src/uvw/event.hpp

@@ -2,6 +2,7 @@
 
 
 #include <cstddef>
+#include <memory>
 #include <uv.h>
 #include "util.hpp"
 
@@ -10,7 +11,16 @@ namespace uvw {
 
 
 struct BaseEvent {
+    BaseEvent() = default;
+
+    BaseEvent(const BaseEvent &) = delete;
+    BaseEvent(BaseEvent &&) = delete;
+
+    void operator=(const BaseEvent &) = delete;
+    void operator=(BaseEvent &&) = delete;
+
     virtual ~BaseEvent() = 0;
+
     static std::size_t next() noexcept {
         static std::size_t cnt = 0;
         return cnt++;
@@ -33,7 +43,16 @@ struct CloseEvent: Event<CloseEvent> { };
 struct ConnectEvent: Event<ConnectEvent> { };
 
 struct DataEvent: Event<DataEvent> {
-    Buffer buffer{};
+    explicit DataEvent(std::unique_ptr<const char[]> ptr, ssize_t l)
+        : dt{std::move(ptr)}, len{l}
+    { }
+
+    const char * data() const noexcept { return dt.get(); }
+    ssize_t length() const noexcept { return len; }
+
+private:
+    std::unique_ptr<const char[]> dt;
+    ssize_t len;
 };
 
 struct EndEvent: Event<EndEvent> { };

src/uvw/stream.hpp

@@ -19,29 +19,21 @@ class Stream: public Handle<T> {
     static constexpr unsigned int DEFAULT_BACKLOG = 128;
 
     static void allocCallback(uv_handle_t *, std::size_t suggested, uv_buf_t *buf) {
-        buf->base = new char[suggested];
-        buf->len = suggested;
+        *buf = uv_buf_init(new char[suggested], suggested);
     }
 
-    static void readCallback(uv_stream_t *handle, ssize_t nread, const uv_buf_t *cbuf) {
+    static void readCallback(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf) {
         T &ref = *(static_cast<T*>(handle->data));
-        uv_buf_t *buf = const_cast<uv_buf_t *>(cbuf);
+        // data will be destroyed no matter of what the value of nread is
+        std::unique_ptr<const char[]> data{buf->base};
 
         if(nread == UV_EOF) {
             ref.publish(EndEvent{});
-            delete[] buf->base;
         } else if(nread > 0) {
-            std::unique_ptr<char[]> data{buf->base};
-            DataEvent event;
-            event.buffer.reset(std::move(data), nread);
-            ref.publish(std::move(event));
+            ref.publish(DataEvent{std::move(data), nread});
         } else {
             ref.publish(ErrorEvent(nread));
-            delete[] buf->base;
         }
-
-        buf->base = nullptr;
-        buf->len = 0;
     }
 
     static void writeCallback(uv_write_t *req, int status) {
@@ -90,19 +82,21 @@ public:
         this->invoke(&uv_read_stop, this->template get<uv_stream_t>());
     }
 
-    void write(Buffer buf) {
-        uv_buf_t data[] = { buf.uvBuf() };
+    void write(std::unique_ptr<char[]> data, ssize_t length) {
+        uv_buf_t bufs[] = { uv_buf_init(data.get(), length) };
         uv_write_t *req = new uv_write_t;
-        auto err = uv_write(req, this->template get<uv_stream_t>(), data, 1, &Stream<T>::writeCallback);
+
+        auto err = uv_write(req, this->template get<uv_stream_t>(), bufs, 1, &Stream<T>::writeCallback);
+
         if(err) {
             delete req;
             this->publish(ErrorEvent{err});
         }
     }
 
-    int tryWrite(Buffer buf) noexcept {
-        uv_buf_t data[] = { buf.uvBuf() };
-        auto bw = uv_try_write(this->template get<uv_stream_t>(), data, 1);
+    int tryWrite(std::unique_ptr<char[]> data, ssize_t length) noexcept {
+        uv_buf_t bufs[] = { uv_buf_init(data.get(), length) };
+        auto bw = uv_try_write(this->template get<uv_stream_t>(), bufs, 1);
 
         if(bw < 0) {
             this->publish(ErrorEvent{bw});

src/uvw/util.hpp

@@ -70,33 +70,4 @@ private:
 using Addr = std::pair<std::string, unsigned int>;
 
 
-class Buffer final {
-    template<typename>
-    friend class Stream;
-
-    uv_buf_t uvBuf() const noexcept {
-        return uv_buf_init(data.get(), size);
-    }
-
-public:
-    Buffer(): data{}, size{} { }
-
-    Buffer(std::unique_ptr<char[]> dt, std::size_t s)
-        : data{std::move(dt)}, size{s}
-    { }
-
-    Buffer(Buffer &&) = default;
-    Buffer& operator=(Buffer &&) = default;
-
-    void reset(std::unique_ptr<char[]> dt, std::size_t s) noexcept {
-        data.swap(dt);
-        size = s;
-    }
-
-private:
-    std::unique_ptr<char[]> data;
-    std::size_t size;
-};
-
-
 }

test/main.cpp

@@ -21,7 +21,7 @@ void listen(uvw::Loop &loop) {
             std::cout << "error " << std::endl;
         });
 
-        client->on<uvw::CloseEvent>([resource = srv.shared_from_this()](uvw::CloseEvent, uvw::Tcp &) mutable {
+        client->on<uvw::CloseEvent>([resource = srv.shared_from_this()](const uvw::CloseEvent &, uvw::Tcp &) mutable {
             std::cout << "close" << std::endl;
 
             uvw::Tcp &srv = *resource;
@@ -37,7 +37,8 @@ void listen(uvw::Loop &loop) {
         std::cout << "remote: " << remote.first << " " << remote.second << std::endl;
 
         client->on<uvw::DataEvent>([](const uvw::DataEvent &event, uvw::Tcp &) {
-            std::cout << "data" << std::endl;
+            std::cout.write(event.data(), event.length()) << std::endl;
+            std::cout << "data length: " << event.length() << std::endl;
         });
 
         client->on<uvw::EndEvent>([](const uvw::EndEvent &, uvw::Tcp &client) {
@@ -64,15 +65,20 @@ void conn(uvw::Loop &loop) {
         std::cout << "error " << std::endl;
     });
 
+    tcp->once<uvw::WriteEvent>([](const uvw::WriteEvent &, uvw::Tcp &tcp) mutable {
+        std::cout << "write" << std::endl;
+        tcp.close();
+    });
+
     tcp->once<uvw::ConnectEvent>([](const uvw::ConnectEvent &, uvw::Tcp &tcp) mutable {
         std::cout << "connect" << std::endl;
 
-        auto data = std::unique_ptr<char[]>(new char[1]);
-        data[0] = 'a';
-        uvw::Buffer buf{std::move(data), 1};
-        int bw = tcp.tryWrite(std::move(buf));
+        auto dataTryWrite = std::unique_ptr<char[]>(new char[1]{ 'a' });
+        int bw = tcp.tryWrite(std::move(dataTryWrite), 1);
         std::cout << "written: " << ((int)bw) << std::endl;
-        tcp.close();
+
+        auto dataWrite = std::unique_ptr<char[]>(new char[2]{ 'b', 'c' });
+        tcp.write(std::move(dataWrite), 2);
     });
 
     tcp->once<uvw::CloseEvent>([](const uvw::CloseEvent &, uvw::Tcp &) mutable {