Merge pull request #9 from ARMmbed/rename-c-equeue-calls

In C api, rename event -> equeue for functions operating on queues

Author: geky

EventQueue.cpp

@@ -29,6 +29,6 @@ unsigned EventQueue::get_tick() {
 }
 
 void EventQueue::cancel(int id) {
-    return event_cancel(&_equeue, id);
+    return equeue_cancel(&_equeue, id);
 }
 

EventQueue.h

@@ -89,14 +89,14 @@ class EventQueue {
      */
     template <typename F>
     int call(F f) {
-        void *p = event_alloc(&_equeue, sizeof(F));
+        void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
             return 0;
         }
 
         F *e = new (p) F(f);
         event_dtor(e, &EventQueue::dtor<F>);
-        return event_post(&_equeue, &EventQueue::call<F>, e);
+        return equeue_post(&_equeue, &EventQueue::call<F>, e);
     }
 
     template <typename F, typename A0>
@@ -134,15 +134,15 @@ class EventQueue {
      */
     template <typename F>
     int call_in(int ms, F f) {
-        void *p = event_alloc(&_equeue, sizeof(F));
+        void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
             return 0;
         }
 
         F *e = new (p) F(f);
         event_delay(e, ms);
         event_dtor(e, &EventQueue::dtor<F>);
-        return event_post(&_equeue, &EventQueue::call<F>, e);
+        return equeue_post(&_equeue, &EventQueue::call<F>, e);
     }
 
     template <typename F, typename A0>
@@ -180,7 +180,7 @@ class EventQueue {
      */
     template <typename F>
     int call_every(int ms, F f) {
-        void *p = event_alloc(&_equeue, sizeof(F));
+        void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
             return 0;
         }
@@ -189,7 +189,7 @@ class EventQueue {
         event_delay(e, ms);
         event_period(e, ms);
         event_dtor(e, &EventQueue::dtor<F>);
-        return event_post(&_equeue, &EventQueue::call<F>, e);
+        return equeue_post(&_equeue, &EventQueue::call<F>, e);
     }
 
     template <typename F, typename A0>

events-c/README.md

@@ -18,9 +18,9 @@ int main() {
     equeue_create(&queue, 32*EVENTS_EVENT_SIZE);
 
     // events are simple callbacks
-    event_call(&queue, print, "called immediately");
-    event_call_in(&queue, print, "called in 2 seconds", 2000);
-    event_call_every(&queue, print, "called every 1 seconds", 1000);
+    equeue_call(&queue, print, "called immediately");
+    equeue_call_in(&queue, print, "called in 2 seconds", 2000);
+    equeue_call_every(&queue, print, "called every 1 seconds", 1000);
 
     // events are executed when dispatch is called
     equeue_dispatch(&queue, 3000);

events-c/events.c

@@ -57,7 +57,7 @@ void equeue_destroy(equeue_t *q) {
     while (q->queue) {
         struct event *e = q->queue;
         q->queue = e->next;
-        event_dealloc(q, e+1);
+        equeue_dealloc(q, e+1);
     }
 
     events_mutex_destroy(&q->freelock);
@@ -67,7 +67,7 @@ void equeue_destroy(equeue_t *q) {
 }
 
 // equeue allocation functions
-static void *equeue_alloc(equeue_t *q, unsigned size) {
+static void *equeue_mem_alloc(equeue_t *q, unsigned size) {
     size = size + sizeof(unsigned);
     size = (size + sizeof(unsigned)-1) & ~(sizeof(unsigned)-1);
     if (size < sizeof(struct equeue_chunk)) {
@@ -103,7 +103,7 @@ static void *equeue_alloc(equeue_t *q, unsigned size) {
     return 0;
 }
 
-static void equeue_dealloc(equeue_t *q, void *e) {
+static void equeue_mem_dealloc(equeue_t *q, void *e) {
     struct equeue_chunk *c = (struct equeue_chunk *)((unsigned *)e - 1);
 
     events_mutex_lock(&q->freelock);
@@ -126,36 +126,36 @@ static void equeue_dealloc(equeue_t *q, void *e) {
 }
 
 // event allocation functions
-static inline int event_next_id(equeue_t *q) {
+static inline int equeue_next_id(equeue_t *q) {
     int id = q->next_id++;
     if (q->next_id < 0) {
         q->next_id = 42;
     }
     return id;
 }
 
-void *event_alloc(equeue_t *q, unsigned size) {
-    struct event *e = equeue_alloc(q, sizeof(struct event) + size);
+void *equeue_alloc(equeue_t *q, unsigned size) {
+    struct event *e = equeue_mem_alloc(q, sizeof(struct event) + size);
     if (!e) {
         return 0;
     }
 
-    e->id = event_next_id(q);
+    e->id = equeue_next_id(q);
     e->target = 0;
     e->period = -1;
     e->dtor = 0;
 
     return e + 1;
 }
 
-void event_dealloc(equeue_t *q, void *p) {
+void equeue_dealloc(equeue_t *q, void *p) {
     struct event *e = (struct event*)p - 1;
 
     if (e->dtor) {
         e->dtor(e+1);
     }
 
-    equeue_dealloc(q, e);
+    equeue_mem_dealloc(q, e);
 }
 
 // equeue scheduling functions
@@ -187,10 +187,10 @@ static struct event *equeue_dequeue(equeue_t *q, int id) {
     return 0;
 }
 
-static int equeue_post(equeue_t *q, struct event *e, int ms) {
+static int equeue_post_in(equeue_t *q, struct event *e, int ms) {
     int id = e->id;
     if (ms < 0) {
-        event_dealloc(q, e+1);
+        equeue_dealloc(q, e+1);
         return id;
     }
 
@@ -202,23 +202,30 @@ static int equeue_post(equeue_t *q, struct event *e, int ms) {
     return id;
 }
 
-static void equeue_cancel(equeue_t *q, int id) {
+int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
+    struct event *e = (struct event*)p - 1;
+    e->cb = cb;
+    int id = equeue_post_in(q, e, e->target);
+    return id;
+}
+
+void equeue_cancel(equeue_t *q, int id) {
     events_mutex_lock(&q->queuelock);
     struct event *e = equeue_dequeue(q, id);
     events_mutex_unlock(&q->queuelock);
 
     if (e) {
-        event_dealloc(q, e+1);
+        equeue_dealloc(q, e+1);
     }
 }
 
 void equeue_break(equeue_t *q) {
-    equeue_post(q, &q->break_, 0);
+    equeue_post_in(q, &q->break_, 0);
 }
 
 void equeue_dispatch(equeue_t *q, int ms) {
     if (ms >= 0) {
-        equeue_post(q, &q->break_, ms);
+        equeue_post_in(q, &q->break_, ms);
     }
 
     while (1) {
@@ -244,7 +251,7 @@ void equeue_dispatch(equeue_t *q, int ms) {
 
             if (e->period >= 0) {
                 // requeue periodic tasks to avoid race conditions
-                // in event_cancel
+                // in equeue_cancel
                 equeue_enqueue(q, e, e->period);
             }
             events_mutex_unlock(&q->queuelock);
@@ -257,7 +264,7 @@ void equeue_dispatch(equeue_t *q, int ms) {
             e->cb(e + 1);
 
             if (e->period < 0) {
-                event_dealloc(q, e+1);
+                equeue_dealloc(q, e+1);
             }
         }
 
@@ -281,18 +288,6 @@ void event_dtor(void *p, void (*dtor)(void *)) {
     e->dtor = dtor;
 }
 
-// event operations
-int event_post(equeue_t *q, void (*cb)(void*), void *p) {
-    struct event *e = (struct event*)p - 1;
-    e->cb = cb;
-    int id = equeue_post(q, e, e->target);
-    return id;
-}
-
-void event_cancel(equeue_t *q, int id) {
-    equeue_cancel(q, id);
-}
-
 // simple callbacks 
 struct ecallback {
     void (*cb)(void*);
@@ -304,31 +299,31 @@ static void ecallback_dispatch(void *p) {
     e->cb(e->data);
 }
 
-int event_call(equeue_t *q, void (*cb)(void*), void *data) {
-    struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
+int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
+    struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
     }
 
     e->cb = cb;
     e->data = data;
-    return event_post(q, ecallback_dispatch, e);
+    return equeue_post(q, ecallback_dispatch, e);
 }
 
-int event_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
-    struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
+int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
+    struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
     }
 
     event_delay(e, ms);
     e->cb = cb;
     e->data = data;
-    return event_post(q, ecallback_dispatch, e);
+    return equeue_post(q, ecallback_dispatch, e);
 }
 
-int event_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
-    struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
+int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
+    struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
     }
@@ -337,5 +332,5 @@ int event_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
     event_period(e, ms);
     e->cb = cb;
     e->data = data;
-    return event_post(q, ecallback_dispatch, e);
+    return equeue_post(q, ecallback_dispatch, e);
 }

events-c/events.h

@@ -80,26 +80,26 @@ void equeue_break(equeue_t *queue);
 // Passed callback will be executed in the associated equeue's
 // dispatch call with the data pointer passed unmodified
 //
-// event_call       - Immediately post an event to the queue
-// event_call_in    - Post an event after a specified time in milliseconds
-// event_call_every - Post an event periodically in milliseconds
+// equeue_call       - Immediately post an event to the queue
+// equeue_call_in    - Post an event after a specified time in milliseconds
+// equeue_call_every - Post an event periodically in milliseconds
 //
 // These calls will result in 0 if no memory is available, otherwise they
-// will result in a unique identifier that can be passed to event_cancel.
-int event_call(equeue_t *queue, void (*cb)(void *), void *data);
-int event_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data);
-int event_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);
+// will result in a unique identifier that can be passed to equeue_cancel.
+int equeue_call(equeue_t *queue, void (*cb)(void *), void *data);
+int equeue_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data);
+int equeue_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);
 
 // Events with queue handled blocks of memory
 //
-// Argument to event_post must point to a result of a event_alloc call
+// Argument to equeue_post must point to a result of a equeue_alloc call
 // and the associated memory is automatically freed after the event
 // is dispatched.
 //
-// event_alloc will result in null if no memory is available
+// equeue_alloc will result in null if no memory is available
 // or the requested size is less than the size passed to equeue_create.
-void *event_alloc(equeue_t *queue, unsigned size);
-void event_dealloc(equeue_t *queue, void *event);
+void *equeue_alloc(equeue_t *queue, unsigned size);
+void equeue_dealloc(equeue_t *queue, void *event);
 
 // Configure an allocated event
 // 
@@ -112,21 +112,21 @@ void event_dtor(void *event, void (*dtor)(void *));
 
 // Post an allocted event to the event queue
 //
-// Argument to event_post must point to a result of a event_alloc call
+// Argument to equeue_post must point to a result of a equeue_alloc call
 // and the associated memory is automatically freed after the event
 // is dispatched.
 //
 // This call results in an unique identifier that can be passed to
-// event_cancel.
-int event_post(equeue_t *queue, void (*cb)(void *), void *event);
+// equeue_cancel.
+int equeue_post(equeue_t *queue, void (*cb)(void *), void *event);
 
 // Cancel events that are in flight
 //
-// Every event_call function returns a non-negative identifier on success
+// Every equeue_call function returns a non-negative identifier on success
 // that can be used to cancel an in-flight event. If the event has already
 // been dispatched or does not exist, no error occurs. Note, this can not
 // stop a currently executing event
-void event_cancel(equeue_t *queue, int event);
+void equeue_cancel(equeue_t *queue, int event);
 
 
 #ifdef __cplusplus