opal-up 0.0.4 → 0.0.5

data/ext/up_ext/Loop.h

@@ -21,184 +21,190 @@
 /* The loop is lazily created per-thread and run with run() */
 
 #include "LoopData.h"
-#include "libusockets.h"
 #include <iostream>
+#include <libusockets.h>
 
 namespace uWS {
 struct Loop {
 private:
-    static void wakeupCb(us_loop_t *loop) {
-        LoopData *loopData = (LoopData *) us_loop_ext(loop);
-
-        /* Swap current deferQueue */
-        loopData->deferMutex.lock();
-        int oldDeferQueue = loopData->currentDeferQueue;
-        loopData->currentDeferQueue = (loopData->currentDeferQueue + 1) % 2;
-        loopData->deferMutex.unlock();
-
-        /* Drain the queue */
-        for (auto &x : loopData->deferQueues[oldDeferQueue]) {
-            x();
-        }
-        loopData->deferQueues[oldDeferQueue].clear();
-    }
-
-    static void preCb(us_loop_t *loop) {
-        LoopData *loopData = (LoopData *) us_loop_ext(loop);
-
-        for (auto &p : loopData->preHandlers) {
-            p.second((Loop *) loop);
-        }
-    }
-
-    static void postCb(us_loop_t *loop) {
-        LoopData *loopData = (LoopData *) us_loop_ext(loop);
-
-        for (auto &p : loopData->postHandlers) {
-            p.second((Loop *) loop);
-        }
-
-        /* After every event loop iteration, we must not hold the cork buffer */
-        if (loopData->corkedSocket) {
-            std::cerr << "Error: Cork buffer must not be held across event loop iterations!" << std::endl;
-            std::terminate();
-        }
-    }
-
-    Loop() = delete;
-    ~Loop() = default;
-
-    Loop *init() {
-        new (us_loop_ext((us_loop_t *) this)) LoopData;
-        return this;
-    }
-
-    static Loop *create(void *hint) {
-        Loop *loop = ((Loop *) us_create_loop(hint, wakeupCb, preCb, postCb, sizeof(LoopData)))->init();
-
-        /* We also need some timers (should live off the one 4 second timer rather) */
-        LoopData *loopData = (LoopData *) us_loop_ext((struct us_loop_t *) loop);
-        loopData->dateTimer = us_create_timer((struct us_loop_t *) loop, 1, sizeof(LoopData *));
-        memcpy(us_timer_ext(loopData->dateTimer), &loopData, sizeof(LoopData *));
-        us_timer_set(loopData->dateTimer, [](struct us_timer_t *t) {
-            LoopData *loopData;
-            memcpy(&loopData, us_timer_ext(t), sizeof(LoopData *));
-            loopData->updateDate();
-        }, 1000, 1000);
-
-        return loop;
-    }
-
-    /* What to do with loops created with existingNativeLoop? */
-    struct LoopCleaner {
-        ~LoopCleaner() {
-            if(loop && cleanMe) {
-                loop->free();
-            }
-        }
-        Loop *loop = nullptr;
-        bool cleanMe = false;
-    };
-
-    static LoopCleaner &getLazyLoop() {
-        static thread_local LoopCleaner lazyLoop;
-        return lazyLoop;
-    }
+  static void wakeupCb(us_loop_t *loop) {
+    LoopData *loopData = (LoopData *)us_loop_ext(loop);
+
+    /* Swap current deferQueue */
+    loopData->deferMutex.lock();
+    int oldDeferQueue = loopData->currentDeferQueue;
+    loopData->currentDeferQueue = (loopData->currentDeferQueue + 1) % 2;
+    loopData->deferMutex.unlock();
+
+    /* Drain the queue */
+    for (auto &x : loopData->deferQueues[oldDeferQueue]) {
+      x();
+    }
+    loopData->deferQueues[oldDeferQueue].clear();
+  }
+
+  static void preCb(us_loop_t *loop) {
+    LoopData *loopData = (LoopData *)us_loop_ext(loop);
+
+    for (auto &p : loopData->preHandlers) {
+      p.second((Loop *)loop);
+    }
+  }
+
+  static void postCb(us_loop_t *loop) {
+    LoopData *loopData = (LoopData *)us_loop_ext(loop);
+
+    for (auto &p : loopData->postHandlers) {
+      p.second((Loop *)loop);
+    }
+
+    /* After every event loop iteration, we must not hold the cork buffer */
+    if (loopData->corkedSocket) {
+      std::cerr
+          << "Error: Cork buffer must not be held across event loop iterations!"
+          << std::endl;
+      std::terminate();
+    }
+  }
+
+  Loop() = delete;
+  ~Loop() = default;
+
+  Loop *init() {
+    new (us_loop_ext((us_loop_t *)this)) LoopData;
+    return this;
+  }
+
+  static Loop *create(void *hint) {
+    Loop *loop = ((Loop *)us_create_loop(hint, wakeupCb, preCb, postCb,
+                                         sizeof(LoopData)))
+                     ->init();
+
+    /* We also need some timers (should live off the one 4 second timer rather)
+     */
+    LoopData *loopData = (LoopData *)us_loop_ext((struct us_loop_t *)loop);
+    loopData->dateTimer =
+        us_create_timer((struct us_loop_t *)loop, 1, sizeof(LoopData *));
+    memcpy(us_timer_ext(loopData->dateTimer), &loopData, sizeof(LoopData *));
+    us_timer_set(
+        loopData->dateTimer,
+        [](struct us_timer_t *t) {
+          LoopData *loopData;
+          memcpy(&loopData, us_timer_ext(t), sizeof(LoopData *));
+          loopData->updateDate();
+        },
+        1000, 1000);
+
+    return loop;
+  }
+
+  /* What to do with loops created with existingNativeLoop? */
+  struct LoopCleaner {
+    ~LoopCleaner() {
+      if (loop && cleanMe) {
+        loop->free();
+      }
+    }
+    Loop *loop = nullptr;
+    bool cleanMe = false;
+  };
+
+  static LoopCleaner &getLazyLoop() {
+    static thread_local LoopCleaner lazyLoop;
+    return lazyLoop;
+  }
 
 public:
-    /* Lazily initializes a per-thread loop and returns it.
-     * Will automatically free all initialized loops at exit. */
-    static Loop *get(void *existingNativeLoop = nullptr) {
-        if (!getLazyLoop().loop) {
-            /* If we are given a native loop pointer we pass that to uSockets and let it deal with it */
-            if (existingNativeLoop) {
-                /* Todo: here we want to pass the pointer, not a boolean */
-                getLazyLoop().loop = create(existingNativeLoop);
-                /* We cannot register automatic free here, must be manually done */
-            } else {
-                getLazyLoop().loop = create(nullptr);
-                getLazyLoop().cleanMe = true;
-            }
-        }
-
-        return getLazyLoop().loop;
-    }
-
-    /* Freeing the default loop should be done once */
-    void free() {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        /* Stop and free dateTimer first */
-        us_timer_close(loopData->dateTimer);
-
-        loopData->~LoopData();
-        /* uSockets will track whether this loop is owned by us or a borrowed alien loop */
-        us_loop_free((us_loop_t *) this);
-
-        /* Reset lazyLoop */
-        getLazyLoop().loop = nullptr;
-    }
-
-    void addPostHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        loopData->postHandlers.emplace(key, std::move(handler));
-    }
-
-    /* Bug: what if you remove a handler while iterating them? */
-    void removePostHandler(void *key) {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        loopData->postHandlers.erase(key);
-    }
-
-    void addPreHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        loopData->preHandlers.emplace(key, std::move(handler));
-    }
-
-    /* Bug: what if you remove a handler while iterating them? */
-    void removePreHandler(void *key) {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        loopData->preHandlers.erase(key);
-    }
-
-    /* Defer this callback on Loop's thread of execution */
-    void defer(MoveOnlyFunction<void()> &&cb) {
-        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
-
-        //if (std::thread::get_id() == ) // todo: add fast path for same thread id
-        loopData->deferMutex.lock();
-        loopData->deferQueues[loopData->currentDeferQueue].emplace_back(std::move(cb));
-        loopData->deferMutex.unlock();
-
-        us_wakeup_loop((us_loop_t *) this);
-    }
-
-    /* Actively block and run this loop */
-    void run() {
-        us_loop_run((us_loop_t *) this);
-    }
-
-    /* Passively integrate with the underlying default loop */
-    /* Used to seamlessly integrate with third parties such as Node.js */
-    void integrate() {
-        us_loop_integrate((us_loop_t *) this);
-    }
-
-    /* Dynamically change this */
-    void setSilent(bool silent) {
-        ((LoopData *) us_loop_ext((us_loop_t *) this))->noMark = silent;
-    }
+  /* Lazily initializes a per-thread loop and returns it.
+   * Will automatically free all initialized loops at exit. */
+  static Loop *get(void *existingNativeLoop = nullptr) {
+    if (!getLazyLoop().loop) {
+      /* If we are given a native loop pointer we pass that to uSockets and let
+       * it deal with it */
+      if (existingNativeLoop) {
+        /* Todo: here we want to pass the pointer, not a boolean */
+        getLazyLoop().loop = create(existingNativeLoop);
+        /* We cannot register automatic free here, must be manually done */
+      } else {
+        getLazyLoop().loop = create(nullptr);
+        getLazyLoop().cleanMe = true;
+      }
+    }
+
+    return getLazyLoop().loop;
+  }
+
+  /* Freeing the default loop should be done once */
+  void free() {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    /* Stop and free dateTimer first */
+    us_timer_close(loopData->dateTimer);
+
+    loopData->~LoopData();
+    /* uSockets will track whether this loop is owned by us or a borrowed alien
+     * loop */
+    us_loop_free((us_loop_t *)this);
+
+    /* Reset lazyLoop */
+    getLazyLoop().loop = nullptr;
+  }
+
+  void addPostHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    loopData->postHandlers.emplace(key, std::move(handler));
+  }
+
+  /* Bug: what if you remove a handler while iterating them? */
+  void removePostHandler(void *key) {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    loopData->postHandlers.erase(key);
+  }
+
+  void addPreHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    loopData->preHandlers.emplace(key, std::move(handler));
+  }
+
+  /* Bug: what if you remove a handler while iterating them? */
+  void removePreHandler(void *key) {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    loopData->preHandlers.erase(key);
+  }
+
+  /* Defer this callback on Loop's thread of execution */
+  void defer(MoveOnlyFunction<void()> &&cb) {
+    LoopData *loopData = (LoopData *)us_loop_ext((us_loop_t *)this);
+
+    // if (std::thread::get_id() == ) // todo: add fast path for same thread id
+    loopData->deferMutex.lock();
+    loopData->deferQueues[loopData->currentDeferQueue].emplace_back(
+        std::move(cb));
+    loopData->deferMutex.unlock();
+
+    us_wakeup_loop((us_loop_t *)this);
+  }
+
+  /* Actively block and run this loop */
+  void run() { us_loop_run((us_loop_t *)this); }
+
+  /* Passively integrate with the underlying default loop */
+  /* Used to seamlessly integrate with third parties such as Node.js */
+  void integrate() { us_loop_integrate((us_loop_t *)this); }
+
+  /* Dynamically change this */
+  void setSilent(bool silent) {
+    ((LoopData *)us_loop_ext((us_loop_t *)this))->noMark = silent;
+  }
 };
 
 /* Can be called from any thread to run the thread local loop */
-inline void run() {
-    Loop::get()->run();
-}
+inline void run() { Loop::get()->run(); }
 
-}
+} // namespace uWS
 
 #endif // UWS_LOOP_H

data/ext/up_ext/LoopData.h

@@ -18,16 +18,16 @@
 #ifndef UWS_LOOPDATA_H
 #define UWS_LOOPDATA_H
 
-#include <thread>
+#include <cstdint>
+#include <ctime>
 #include <functional>
-#include <vector>
-#include <mutex>
 #include <map>
-#include <ctime>
-#include <cstdint>
+#include <mutex>
+#include <thread>
+#include <vector>
 
-#include "PerMessageDeflate.h"
 #include "MoveOnlyFunction.h"
+#include "PerMessageDeflate.h"
 
 struct us_timer_t;
 
@@ -36,77 +36,70 @@ namespace uWS {
 struct Loop;
 
 struct alignas(16) LoopData {
-    friend struct Loop;
+  friend struct Loop;
+
 private:
-    std::mutex deferMutex;
-    int currentDeferQueue = 0;
-    std::vector<MoveOnlyFunction<void()>> deferQueues[2];
+  std::mutex deferMutex;
+  int currentDeferQueue = 0;
+  std::vector<MoveOnlyFunction<void()>> deferQueues[2];
 
-    /* Map from void ptr to handler */
-    std::map<void *, MoveOnlyFunction<void(Loop *)>> postHandlers, preHandlers;
+  /* Map from void ptr to handler */
+  std::map<void *, MoveOnlyFunction<void(Loop *)>> postHandlers, preHandlers;
 
 public:
-    LoopData() {
-        updateDate();
-    }
-
-    ~LoopData() {
-        /* If we have had App.ws called with compression we need to clear this */
-        if (zlibContext) {
-            delete zlibContext;
-            delete inflationStream;
-            delete deflationStream;
-        }
-        delete [] corkBuffer;
+  LoopData() { updateDate(); }
+
+  ~LoopData() {
+    /* If we have had App.ws called with compression we need to clear this */
+    if (zlibContext) {
+      delete zlibContext;
+      delete inflationStream;
+      delete deflationStream;
     }
+    delete[] corkBuffer;
+  }
 
-    void updateDate() {
-        time_t now = time(0);
-        struct tm tstruct = {};
+  void updateDate() {
+    time_t now = time(0);
+    struct tm tstruct = {};
 #ifdef _WIN32
-        /* Micro, fucking soft never follows spec. */
-        gmtime_s(&tstruct, &now);
+    /* Micro, fucking soft never follows spec. */
+    gmtime_s(&tstruct, &now);
 #else
-        gmtime_r(&now, &tstruct);
+    gmtime_r(&now, &tstruct);
 #endif
-        static const char wday_name[][4] = {
-            "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-        };
-        static const char mon_name[][4] = {
-            "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-            "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-        };
-        snprintf(date, 32, "%.3s, %.2u %.3s %.4u %.2u:%.2u:%.2u GMT",
-            wday_name[tstruct.tm_wday],
-            tstruct.tm_mday % 99,
-            mon_name[tstruct.tm_mon],
-            (1900 + tstruct.tm_year) % 9999,
-            tstruct.tm_hour % 99,
-            tstruct.tm_min % 99,
-            tstruct.tm_sec % 99);
-    }
-
-    char date[32];
-
-    /* Be silent */
-    bool noMark = false;
-
-    /* Good 16k for SSL perf. */
-    static const unsigned int CORK_BUFFER_SIZE = 16 * 1024;
-
-    /* Cork data */
-    char *corkBuffer = new char[CORK_BUFFER_SIZE];
-    unsigned int corkOffset = 0;
-    void *corkedSocket = nullptr;
-
-    /* Per message deflate data */
-    ZlibContext *zlibContext = nullptr;
-    InflationStream *inflationStream = nullptr;
-    DeflationStream *deflationStream = nullptr;
-
-    us_timer_t *dateTimer;
+    static const char wday_name[][4] = {"Sun", "Mon", "Tue", "Wed",
+                                        "Thu", "Fri", "Sat"};
+    static const char mon_name[][4] = {"Jan", "Feb", "Mar", "Apr",
+                                       "May", "Jun", "Jul", "Aug",
+                                       "Sep", "Oct", "Nov", "Dec"};
+    snprintf(date, 32, "%.3s, %.2u %.3s %.4u %.2u:%.2u:%.2u GMT",
+             wday_name[tstruct.tm_wday], tstruct.tm_mday % 99,
+             mon_name[tstruct.tm_mon], (1900 + tstruct.tm_year) % 9999,
+             tstruct.tm_hour % 99, tstruct.tm_min % 99, tstruct.tm_sec % 99);
+  }
+
+  char date[32];
+
+  /* Be silent */
+  bool noMark = false;
+
+  /* Good 16k for SSL perf. */
+  static const unsigned int CORK_BUFFER_SIZE = 16 * 1024;
+
+  /* Cork data */
+  char *corkBuffer = new char[CORK_BUFFER_SIZE];
+  unsigned int corkOffset = 0;
+  void *corkedSocket = nullptr;
+
+  /* Per message deflate data */
+  ZlibContext *zlibContext = nullptr;
+  InflationStream *inflationStream = nullptr;
+  DeflationStream *deflationStream = nullptr;
+
+  us_timer_t *dateTimer;
 };
 
-}
+} // namespace uWS
 
 #endif // UWS_LOOPDATA_H