Christopher Haster / events

Note! This project has moved to github.com/armmbed/mbed-events

Dependents:   SimpleHTTPExample

This repository has been superceded

This project has moved to mbed-events

Composable event loops combine the cheap synchronicity of event loops with the composability of preempted threads.

Two modular event queue classes are provided:

  • EventLoop - for loops coupled with a c++ managed thread
  • EventQueue - for manually managed event queues

The Event class takes advantage of the extensibility of FuncPtr to allow an event to be passed through APIs as a normal function.

More information on composable event loops.

Diff: EventQueue.h

Revision:
19:86ffaa34870b
Parent:
18:765776145464
Child:
20:2f9d9c53a5af
--- a/EventQueue.h	Mon Apr 18 12:58:26 2016 -0500
+++ b/EventQueue.h	Mon Apr 18 12:59:37 2016 -0500
@@ -205,17 +205,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return event_trigger(Binder<void(A0,A1,A2,A3,A4),A0,A1,A2,A3,A4>(func,a0,a1,a2,a3,a4), ms, -1, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2,A3,A4)>(obj,func),a0,a1,a2,a3,a4,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2,A3,A4)>(obj,func),a0,a1,a2,a3,a4,ms);
     }
 
@@ -223,17 +223,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return event_trigger(Binder<void(A0,A1,A2,A3),A0,A1,A2,A3>(func,a0,a1,a2,a3), ms, -1, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2,A3)>(obj,func),a0,a1,a2,a3,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2,A3)>(obj,func),a0,a1,a2,a3,ms);
     }
 
@@ -241,17 +241,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2>
-    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_in(F func, A0 a0, A1 a1, A2 a2, int ms) {
         return event_trigger(Binder<void(A0,A1,A2),A0,A1,A2>(func,a0,a1,a2), ms, -1, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2>
-    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*,A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2)>(obj,func),a0,a1,a2,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2>
-    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms) {
         return trigger_in(FuncPtr<void(A0,A1,A2)>(obj,func),a0,a1,a2,ms);
     }
 
@@ -259,17 +259,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1>
-    bool trigger_in(F func, A0 a0, A1 a1, int ms=-1) {
+    bool trigger_in(F func, A0 a0, A1 a1, int ms) {
         return event_trigger(Binder<void(A0,A1),A0,A1>(func,a0,a1), ms, -1, 0);
     }
 
     template <typename T, typename A0, typename A1>
-    bool trigger_in(T *obj, void (*func)(T*,A0,A1), A0 a0, A1 a1, int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*,A0,A1), A0 a0, A1 a1, int ms) {
         return trigger_in(FuncPtr<void(A0,A1)>(obj,func),a0,a1,ms);
     }
 
     template <typename T, typename A0, typename A1>
-    bool trigger_in(T *obj, void (T::*func)(A0,A1), A0 a0, A1 a1, int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(A0,A1), A0 a0, A1 a1, int ms) {
         return trigger_in(FuncPtr<void(A0,A1)>(obj,func),a0,a1,ms);
     }
 
@@ -277,17 +277,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0>
-    bool trigger_in(F func, A0 a0, int ms=-1) {
+    bool trigger_in(F func, A0 a0, int ms) {
         return event_trigger(Binder<void(A0),A0>(func,a0), ms, -1, 0);
     }
 
     template <typename T, typename A0>
-    bool trigger_in(T *obj, void (*func)(T*,A0), A0 a0, int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*,A0), A0 a0, int ms) {
         return trigger_in(FuncPtr<void(A0)>(obj,func),a0,ms);
     }
 
     template <typename T, typename A0>
-    bool trigger_in(T *obj, void (T::*func)(A0), A0 a0, int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(A0), A0 a0, int ms) {
         return trigger_in(FuncPtr<void(A0)>(obj,func),a0,ms);
     }
 
@@ -295,17 +295,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F>
-    bool trigger_in(F func, int ms=-1) {
+    bool trigger_in(F func, int ms) {
         return event_trigger(Binder<void()>(func), ms, -1, 0);
     }
 
     template <typename T>
-    bool trigger_in(T *obj, void (*func)(T*), int ms=-1) {
+    bool trigger_in(T *obj, void (*func)(T*), int ms) {
         return trigger_in(FuncPtr<void()>(obj,func),ms);
     }
 
     template <typename T>
-    bool trigger_in(T *obj, void (T::*func)(), int ms=-1) {
+    bool trigger_in(T *obj, void (T::*func)(), int ms) {
         return trigger_in(FuncPtr<void()>(obj,func),ms);
     }
 
@@ -313,17 +313,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return event_trigger(Binder<void(A0,A1,A2,A3,A4),A0,A1,A2,A3,A4>(func,a0,a1,a2,a3,a4), 0, ms, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2,A3,A4)>(obj,func),a0,a1,a2,a3,a4,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
-    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2,A3,A4), A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2,A3,A4)>(obj,func),a0,a1,a2,a3,a4,ms);
     }
 
@@ -331,17 +331,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return event_trigger(Binder<void(A0,A1,A2,A3),A0,A1,A2,A3>(func,a0,a1,a2,a3), 0, ms, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2,A3)>(obj,func),a0,a1,a2,a3,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2, typename A3>
-    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2,A3), A0 a0, A1 a1, A2 a2, A3 a3, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2,A3)>(obj,func),a0,a1,a2,a3,ms);
     }
 
@@ -349,17 +349,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1, typename A2>
-    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_every(F func, A0 a0, A1 a1, A2 a2, int ms) {
         return event_trigger(Binder<void(A0,A1,A2),A0,A1,A2>(func,a0,a1,a2), 0, ms, 0);
     }
 
     template <typename T, typename A0, typename A1, typename A2>
-    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*,A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2)>(obj,func),a0,a1,a2,ms);
     }
 
     template <typename T, typename A0, typename A1, typename A2>
-    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(A0,A1,A2), A0 a0, A1 a1, A2 a2, int ms) {
         return trigger_every(FuncPtr<void(A0,A1,A2)>(obj,func),a0,a1,a2,ms);
     }
 
@@ -367,17 +367,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0, typename A1>
-    bool trigger_every(F func, A0 a0, A1 a1, int ms=-1) {
+    bool trigger_every(F func, A0 a0, A1 a1, int ms) {
         return event_trigger(Binder<void(A0,A1),A0,A1>(func,a0,a1), 0, ms, 0);
     }
 
     template <typename T, typename A0, typename A1>
-    bool trigger_every(T *obj, void (*func)(T*,A0,A1), A0 a0, A1 a1, int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*,A0,A1), A0 a0, A1 a1, int ms) {
         return trigger_every(FuncPtr<void(A0,A1)>(obj,func),a0,a1,ms);
     }
 
     template <typename T, typename A0, typename A1>
-    bool trigger_every(T *obj, void (T::*func)(A0,A1), A0 a0, A1 a1, int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(A0,A1), A0 a0, A1 a1, int ms) {
         return trigger_every(FuncPtr<void(A0,A1)>(obj,func),a0,a1,ms);
     }
 
@@ -385,17 +385,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F, typename A0>
-    bool trigger_every(F func, A0 a0, int ms=-1) {
+    bool trigger_every(F func, A0 a0, int ms) {
         return event_trigger(Binder<void(A0),A0>(func,a0), 0, ms, 0);
     }
 
     template <typename T, typename A0>
-    bool trigger_every(T *obj, void (*func)(T*,A0), A0 a0, int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*,A0), A0 a0, int ms) {
         return trigger_every(FuncPtr<void(A0)>(obj,func),a0,ms);
     }
 
     template <typename T, typename A0>
-    bool trigger_every(T *obj, void (T::*func)(A0), A0 a0, int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(A0), A0 a0, int ms) {
         return trigger_every(FuncPtr<void(A0)>(obj,func),a0,ms);
     }
 
@@ -403,17 +403,17 @@
      *  @param ms   Delay in milliseconds
      */
     template <typename F>
-    bool trigger_every(F func, int ms=-1) {
+    bool trigger_every(F func, int ms) {
         return event_trigger(Binder<void()>(func), 0, ms, 0);
     }
 
     template <typename T>
-    bool trigger_every(T *obj, void (*func)(T*), int ms=-1) {
+    bool trigger_every(T *obj, void (*func)(T*), int ms) {
         return trigger_every(FuncPtr<void()>(obj,func),ms);
     }
 
     template <typename T>
-    bool trigger_every(T *obj, void (T::*func)(), int ms=-1) {
+    bool trigger_every(T *obj, void (T::*func)(), int ms) {
         return trigger_every(FuncPtr<void()>(obj,func),ms);
     }
 };