added Signal handle

src/uvw.hpp

@@ -6,6 +6,7 @@
 #include "uvw/loop.hpp"
 #include "uvw/prepare.hpp"
 #include "uvw/request.hpp"
+#include "uvw/signal.hpp"
 #include "uvw/stream.hpp"
 #include "uvw/tcp.hpp"
 #include "uvw/timer.hpp"

src/uvw/event.hpp

@@ -34,6 +34,7 @@ struct CheckEvent: Event<CheckEvent> { };
 struct CloseEvent: Event<CloseEvent> { };
 struct ConnectEvent: Event<ConnectEvent> { };
 
+
 struct DataEvent: Event<DataEvent> {
     explicit DataEvent(std::unique_ptr<const char[]> ptr, ssize_t l)
         : dt{std::move(ptr)}, len{l}
@@ -47,8 +48,10 @@ private:
     ssize_t len;
 };
 
+
 struct EndEvent: Event<EndEvent> { };
 
+
 struct ErrorEvent: Event<ErrorEvent> {
     explicit ErrorEvent(int code = 0): ec(code) { }
 
@@ -59,10 +62,23 @@ private:
     int ec;
 };
 
+
 struct IdleEvent: Event<IdleEvent> { };
 struct ListenEvent: Event<ListenEvent> { };
 struct PrepareEvent: Event<PrepareEvent> { };
 struct ShutdownEvent: Event<ShutdownEvent> { };
+
+
+struct SignalEvent: Event<SignalEvent> {
+    explicit SignalEvent(int sig): signum(sig) { }
+
+    operator int() const noexcept { return signum; }
+
+private:
+    int signum;
+};
+
+
 struct TimerEvent: Event<TimerEvent> { };
 struct UninitializedEvent: Event<UninitializedEvent> { };
 struct WriteEvent: Event<WriteEvent> { };

src/uvw/signal.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+
+#include <utility>
+#include <memory>
+#include <uv.h>
+#include "event.hpp"
+#include "handle.hpp"
+#include "util.hpp"
+
+
+namespace uvw {
+
+
+class Signal final: public Handle<Signal> {
+    static void startCallback(uv_signal_t *handle, int signum) {
+        Signal &signal = *(static_cast<Signal*>(handle->data));
+        signal.publish(SignalEvent{signum});
+    }
+
+    using Handle<Signal>::Handle;
+
+public:
+    template<typename... Args>
+    static std::shared_ptr<Signal> create(Args&&... args) {
+        return std::shared_ptr<Signal>{new Signal{std::forward<Args>(args)...}};
+    }
+
+    bool init() { return initialize<uv_signal_t>(&uv_signal_init); }
+
+    void start(int signum) { invoke(uv_signal_start, get<uv_signal_t>(), &startCallback, signum); }
+    void stop() { invoke(&uv_signal_stop, get<uv_signal_t>()); }
+};
+
+
+}