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: Event.h

Revision:
3:6dccdc36651f
Parent:
2:11cda6bead99
Child:
4:30883e8633b4
--- a/Event.h	Wed Apr 20 14:15:54 2016 -0500
+++ b/Event.h	Wed Apr 20 14:31:17 2016 -0500
@@ -37,6 +37,16 @@
         attach(queue, callback);
     }
 
+    /** Create an event bound to a queue
+     */
+    template <typename T, typename M>
+    Event(EventQueue *queue, T *obj, M method) {
+        memset(&_event, 0, sizeof _event);
+        _event.delay = 0;
+        _event.period = -1;
+        attach(queue, obj, method);
+    }
+
     /** Safe lifetime management
      */
     ~Event() {
@@ -50,6 +60,14 @@
         _callback.attach(callback);
     }
 
+    /** Attach an event to a queue
+     */
+    template <typename T, typename M>
+    void attach(EventQueue *queue, T *obj, M method) {
+        _queue = queue;
+        _callback.attach(FuncPtr<void(A0, A1, A2, A3)>(obj, method));
+    }
+
     /** Set delay for when the event is dispatched after it is posted
      *  @param ms   Delay in milliseconds
      */
@@ -135,6 +153,16 @@
         attach(queue, callback);
     }
 
+    /** Create an event bound to a queue
+     */
+    template <typename T, typename M>
+    Event(EventQueue *queue, T *obj, M method) {
+        memset(&_event, 0, sizeof _event);
+        _event.delay = 0;
+        _event.period = -1;
+        attach(queue, obj, method);
+    }
+
     /** Safe lifetime management
      */
     ~Event() {
@@ -148,6 +176,14 @@
         _callback.attach(callback);
     }
 
+    /** Attach an event to a queue
+     */
+    template <typename T, typename M>
+    void attach(EventQueue *queue, T *obj, M method) {
+        _queue = queue;
+        _callback.attach(FuncPtr<void(A0, A1, A2)>(obj, method));
+    }
+
     /** Set delay for when the event is dispatched after it is posted
      *  @param ms   Delay in milliseconds
      */
@@ -233,6 +269,16 @@
         attach(queue, callback);
     }
 
+    /** Create an event bound to a queue
+     */
+    template <typename T, typename M>
+    Event(EventQueue *queue, T *obj, M method) {
+        memset(&_event, 0, sizeof _event);
+        _event.delay = 0;
+        _event.period = -1;
+        attach(queue, obj, method);
+    }
+
     /** Safe lifetime management
      */
     ~Event() {
@@ -246,6 +292,14 @@
         _callback.attach(callback);
     }
 
+    /** Attach an event to a queue
+     */
+    template <typename T, typename M>
+    void attach(EventQueue *queue, T *obj, M method) {
+        _queue = queue;
+        _callback.attach(FuncPtr<void(A0, A1)>(obj, method));
+    }
+
     /** Set delay for when the event is dispatched after it is posted
      *  @param ms   Delay in milliseconds
      */
@@ -331,6 +385,16 @@
         attach(queue, callback);
     }
 
+    /** Create an event bound to a queue
+     */
+    template <typename T, typename M>
+    Event(EventQueue *queue, T *obj, M method) {
+        memset(&_event, 0, sizeof _event);
+        _event.delay = 0;
+        _event.period = -1;
+        attach(queue, obj, method);
+    }
+
     /** Safe lifetime management
      */
     ~Event() {
@@ -344,6 +408,14 @@
         _callback.attach(callback);
     }
 
+    /** Attach an event to a queue
+     */
+    template <typename T, typename M>
+    void attach(EventQueue *queue, T *obj, M method) {
+        _queue = queue;
+        _callback.attach(FuncPtr<void(A0)>(obj, method));
+    }
+
     /** Set delay for when the event is dispatched after it is posted
      *  @param ms   Delay in milliseconds
      */
@@ -429,6 +501,16 @@
         attach(queue, callback);
     }
 
+    /** Create an event bound to a queue
+     */
+    template <typename T, typename M>
+    Event(EventQueue *queue, T *obj, M method) {
+        memset(&_event, 0, sizeof _event);
+        _event.delay = 0;
+        _event.period = -1;
+        attach(queue, obj, method);
+    }
+
     /** Safe lifetime management
      */
     ~Event() {
@@ -442,6 +524,14 @@
         _callback.attach(callback);
     }
 
+    /** Attach an event to a queue
+     */
+    template <typename T, typename M>
+    void attach(EventQueue *queue, T *obj, M method) {
+        _queue = queue;
+        _callback.attach(FuncPtr<void()>(obj, method));
+    }
+
     /** Set delay for when the event is dispatched after it is posted
      *  @param ms   Delay in milliseconds
      */