create libuv.h based on libev.h

include/libuv.h

@@ -0,0 +1,220 @@
+/**
+ *  LibUV.h
+ *
+ *  Implementation for the AMQP::TcpHandler that is optimized for libuv. You can
+ *  use this class instead of a AMQP::TcpHandler class, just pass the event loop
+ *  to the constructor and you're all set.
+ *
+ *  Based heavily on the libev.h implementation by Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
+ *
+ *  @author David Nikdel <david@nikdel.com>
+ *  @copyright 2015 Copernica BV
+ */
+
+/**
+ *  Include guard
+ */
+#pragma once
+
+/**
+ *  Dependencies
+ */
+#include <uv.h>
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  Class definition
+ */
+class LibUvHandler : public TcpHandler
+{
+private:
+    /**
+     *  Helper class that wraps a libev I/O watcher
+     */
+    class Watcher
+    {
+    private:
+        /**
+         *  The event loop to which it is attached
+         *  @var struct uv_loop_t
+         */
+        struct uv_loop_t *_loop;
+
+        /**
+         *  The actual watcher structure
+         *  @var struct uv_poll_t
+         */
+        struct uv_poll_t *_poll;
+
+        /**
+         *  Callback method that is called by libuv when a filedescriptor becomes active
+         *  @param  handle     Internal poll handle
+         *  @param  status     LibUV error code UV_*
+         *  @param  events     Events triggered
+         */
+        static void callback(struct uv_poll_t *handle, int status, int events)
+        {
+            // retrieve the connection
+            TcpConnection *connection = static_cast<TcpConnection*>(handle->data);
+
+            // tell the connection that its filedescriptor is active
+            int fd = -1;
+            uv_fileno(static_cast<uv_handle_t*>(handle), &fd);
+            connection->process(fd, uv_to_amqp_events(events));
+        }
+
+    public:
+        /**
+         *  Constructor
+         *  @param  loop            The current event loop
+         *  @param  connection      The connection being watched
+         *  @param  fd              The filedescriptor being watched
+         *  @param  events          The events that should be monitored
+         */
+        Watcher(struct uv_loop_t *loop, TcpConnection *connection, int fd, int events) : _loop(loop)
+        {
+            // create a new poll
+            _poll = new uv_poll_t();
+
+            // initialize the libev structure
+            uv_poll_init(_loop, _poll, fd);
+
+            // store the connection in the data "void*"
+            _poll->data = connection;
+
+            // start the watcher
+            uv_poll_start(_poll, amqp_to_uv_events(events), callback);
+        }
+
+        /**
+         *  Watchers cannot be copied or moved
+         *
+         *  @param  that    The object to not move or copy
+         */
+        Watcher(Watcher &&that) = delete;
+        Watcher(const Watcher &that) = delete;
+
+        /**
+         *  Destructor
+         */
+        virtual ~Watcher()
+        {
+            // stop the watcher
+            uv_poll_stop(_poll);
+
+            // close the handle
+            uv_close(static_cast<uv_handle_t*>(_poll), [](uv_handle_t* handle) {
+                // delete memory once closed
+                delete static_cast<uv_poll_t*>(handle);
+            });
+        }
+
+        /**
+         *  Change the events for which the filedescriptor is monitored
+         *  @param  events
+         */
+        void events(int events)
+        {
+            // stop the watcher if it was active
+            uv_poll_stop(_poll);
+
+            // and restart it
+            uv_poll_start(_poll, amqp_to_uv_events(events), callback);
+        }
+
+    private:
+
+        /**
+         *  Convert event flags from UV format to AMQP format
+         */
+        static int uv_to_amqp_events(int events)
+        {
+            int amqp_events = 0;
+            if (events & UV_READABLE)
+                amqp_events |= AMQP::readable;
+            if (events & UV_WRITABLE)
+                amqp_events |= AMQP::writable;
+            return amqp_events;
+        }
+
+        /**
+         *  Convert event flags from AMQP format to UV format
+         */
+        static int amqp_to_uv_events(int events)
+        {
+            int uv_events = 0;
+            if (events & AMQP::readable)
+                uv_events |= UV_READABLE;
+            if (events & AMQP::writable)
+                uv_events |= UV_WRITABLE;
+            return uv_events;
+        }
+    };
+
+
+    /**
+     *  The event loop
+     *  @var struct uv_loop_t*
+     */
+    struct uv_loop_t *_loop;
+
+    /**
+     *  All I/O watchers that are active, indexed by their filedescriptor
+     *  @var std::map<int,Watcher>
+     */
+    std::map<int,std::unique_ptr<Watcher>> _watchers;
+
+
+    /**
+     *  Method that is called by AMQP-CPP to register a filedescriptor for readability or writability
+     *  @param  connection  The TCP connection object that is reporting
+     *  @param  fd          The filedescriptor to be monitored
+     *  @param  flags       Should the object be monitored for readability or writability?
+     */
+    virtual void monitor(TcpConnection *connection, int fd, int flags) override
+    {
+        // do we already have this filedescriptor
+        auto iter = _watchers.find(fd);
+
+        // was it found?
+        if (iter == _watchers.end())
+        {
+            // we did not yet have this watcher - but that is ok if no filedescriptor was registered
+            if (flags == 0) return;
+
+            // construct a new watcher, and put it in the map
+            _watchers[fd] = std::unique_ptr<Watcher>(new Watcher(_loop, connection, fd, flags));
+        }
+        else if (flags == 0)
+        {
+            // the watcher does already exist, but we no longer have to watch this watcher
+            _watchers.erase(iter);
+        }
+        else
+        {
+            // change the events
+            iter->second->events(flags);
+        }
+    }
+
+public:
+    /**
+     *  Constructor
+     *  @param  loop    The event loop to wrap
+     */
+    LibUvHandler(struct uv_loop_t *loop) : _loop(loop) {}
+
+    /**
+     *  Destructor
+     */
+    virtual ~LibUvHandler() = default;
+};
+
+/**
+ *  End of namespace
+ */
+}