Merge pull request #8 from cynnyx/master

write requests -> Write/Request

src/uvw/request.hpp

@@ -16,6 +16,7 @@ struct RequestType;
 template<> struct RequestType<uv_connect_t> { };
 template<> struct RequestType<uv_shutdown_t> { };
 template<> struct RequestType<uv_work_t> { };
+template<> struct RequestType<uv_write_t> { };
 
 
 template<typename T>

src/uvw/stream.hpp

@@ -29,9 +29,25 @@ public:
         return std::shared_ptr<Shutdown>{new Shutdown{std::forward<Args>(args)...}};
     }
 
-    template<typename T>
+    void shutdown(uv_stream_t *handle) noexcept {
-    void shutdown(uv_stream_t *stream) noexcept {
+        exec<uv_shutdown_t, ShutdownEvent>(&uv_shutdown, get<uv_shutdown_t>(), handle);
-        exec<uv_shutdown_t, ShutdownEvent>(&uv_shutdown, get<uv_shutdown_t>(), stream);
+    }
+};
+
+
+class Write final: public Request<Write> {
+    explicit Write(std::shared_ptr<Loop> ref)
+        : Request{RequestType<uv_write_t>{}, std::move(ref)}
+    { }
+
+public:
+    template<typename... Args>
+    static std::shared_ptr<Write> create(Args&&... args) {
+        return std::shared_ptr<Write>{new Write{std::forward<Args>(args)...}};
+    }
+
+    void write(uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs) {
+        exec<uv_write_t, WriteEvent>(&uv_write, get<uv_write_t>(), handle, bufs, nbufs);
     }
 };
 
@@ -61,14 +77,6 @@ class Stream: public Handle<T> {
         }
     }
 
-    static void writeCallback(uv_write_t *req, int status) {
-        // TODO migrate to Request (see request.hpp for further details)
-        T &ref = *(static_cast<T*>(req->handle->data));
-        if(status) { ref.publish(ErrorEvent{status}); }
-        else { ref.publish(WriteEvent{}); }
-        delete req;
-    }
-
     static void listenCallback(uv_stream_t *handle, int status) {
         T &ref = *(static_cast<T*>(handle->data));
         if(status) ref.publish(ErrorEvent{status});
@@ -114,15 +122,17 @@ public:
 
     void write(char *data, ssize_t length) {
         uv_buf_t bufs[] = { uv_buf_init(data, length) };
-        // TODO migrate to Request (see request.hpp for further details)
+        std::weak_ptr<T> weak = this->shared_from_this();
-        uv_write_t *req = new uv_write_t;
 
-        auto err = uv_write(req, this->template get<uv_stream_t>(), bufs, 1, &Stream<T>::writeCallback);
+        auto listener = [weak](const auto &event, details::Write &) {
+            auto ptr = weak.lock();
+            if(ptr) { ptr->publish(event); }
+        };
 
-        if(err) {
+        auto write = this->loop().template resource<details::Write>();
-            delete req;
+        write->template once<ErrorEvent>(listener);
-            this->publish(ErrorEvent{err});
+        write->template once<WriteEvent>(listener);
-        }
+        write->write(this->template get<uv_stream_t>(), bufs, 1);
     }
 
     void write(std::unique_ptr<char[]> data, ssize_t length) {

src/uvw/tcp.hpp

@@ -19,21 +19,6 @@ namespace details {
 
 
 class Connect final: public Request<Connect> {
-    static void connectCallback(uv_connect_t *req, int status) {
-        Connect &connect = *(static_cast<Connect*>(req->data));
-
-        auto ptr = connect.shared_from_this();
-        (void)ptr;
-
-        connect.reset();
-
-        if(status) {
-            connect.publish(ErrorEvent{status});
-        } else {
-            connect.publish(ConnectEvent{});
-        }
-    }
-
     explicit Connect(std::shared_ptr<Loop> ref)
         : Request{RequestType<uv_connect_t>{}, std::move(ref)}
     { }
@@ -44,8 +29,8 @@ public:
         return std::shared_ptr<Connect>{new Connect{std::forward<Args>(args)...}};
     }
 
-    void connect(uv_tcp_t *tcp, const sockaddr *addr) noexcept {
+    void connect(uv_tcp_t *handle, const sockaddr *addr) noexcept {
-        exec<uv_connect_t, ConnectEvent>(&uv_tcp_connect, get<uv_connect_t>(), tcp, addr);
+        exec<uv_connect_t, ConnectEvent>(&uv_tcp_connect, get<uv_connect_t>(), handle, addr);
     }
 };