Adopted functional template style in Event

Before:
Event<A, B, C>

After:
Event<void(A, B, C)>

Author: geky

Event.h

@@ -25,15 +25,15 @@ namespace events {
  *
  *  Representation of an event for fine-grain dispatch control
  */
-template <typename A0=void, typename A1=void, typename A2=void, typename A3=void, typename A4=void>
+template <typename F>
 class Event;
 
 /** Event
  *
  *  Representation of an event for fine-grain dispatch control
  */
 template <>
-class Event<> {
+class Event<void()> {
 public:
     /** Event lifetime
      *
@@ -226,14 +226,15 @@ class Event<> {
  *  Representation of an event for fine-grain dispatch control
  */
 template <typename A0>
-class Event<A0> {
+class Event<void(A0)> {
 public:
     /** Event lifetime
      *
      *  Constructs an event bound to the specified event queue. The specified
      *  callback acts as the target for the event and is executed in the
      *  context of the event queue's dispatch loop once posted.
      *
+     *  @param q        Event queue to dispatch on
      *  @param f        Function to execute when the event is dispatched
      *  @param a0..a4   Arguments to pass to the callback
      */
@@ -418,14 +419,15 @@ class Event<A0> {
  *  Representation of an event for fine-grain dispatch control
  */
 template <typename A0, typename A1>
-class Event<A0, A1> {
+class Event<void(A0, A1)> {
 public:
     /** Event lifetime
      *
      *  Constructs an event bound to the specified event queue. The specified
      *  callback acts as the target for the event and is executed in the
      *  context of the event queue's dispatch loop once posted.
      *
+     *  @param q        Event queue to dispatch on
      *  @param f        Function to execute when the event is dispatched
      *  @param a0..a4   Arguments to pass to the callback
      */
@@ -610,14 +612,15 @@ class Event<A0, A1> {
  *  Representation of an event for fine-grain dispatch control
  */
 template <typename A0, typename A1, typename A2>
-class Event<A0, A1, A2> {
+class Event<void(A0, A1, A2)> {
 public:
     /** Event lifetime
      *
      *  Constructs an event bound to the specified event queue. The specified
      *  callback acts as the target for the event and is executed in the
      *  context of the event queue's dispatch loop once posted.
      *
+     *  @param q        Event queue to dispatch on
      *  @param f        Function to execute when the event is dispatched
      *  @param a0..a4   Arguments to pass to the callback
      */
@@ -802,14 +805,15 @@ class Event<A0, A1, A2> {
  *  Representation of an event for fine-grain dispatch control
  */
 template <typename A0, typename A1, typename A2, typename A3>
-class Event<A0, A1, A2, A3> {
+class Event<void(A0, A1, A2, A3)> {
 public:
     /** Event lifetime
      *
      *  Constructs an event bound to the specified event queue. The specified
      *  callback acts as the target for the event and is executed in the
      *  context of the event queue's dispatch loop once posted.
      *
+     *  @param q        Event queue to dispatch on
      *  @param f        Function to execute when the event is dispatched
      *  @param a0..a4   Arguments to pass to the callback
      */
@@ -994,14 +998,15 @@ class Event<A0, A1, A2, A3> {
  *  Representation of an event for fine-grain dispatch control
  */
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-class Event {
+class Event<void(A0, A1, A2, A3, A4)> {
 public:
     /** Event lifetime
      *
      *  Constructs an event bound to the specified event queue. The specified
      *  callback acts as the target for the event and is executed in the
      *  context of the event queue's dispatch loop once posted.
      *
+     *  @param q        Event queue to dispatch on
      *  @param f        Function to execute when the event is dispatched
      *  @param a0..a4   Arguments to pass to the callback
      */
@@ -1183,35 +1188,35 @@ class Event {
 
 
 template <typename F>
-Event<> EventQueue::event(F f) {
-    return Event<>(this, f);
+Event<void()> EventQueue::event(F f) {
+    return Event<void()>(this, f);
 }
 
 template <typename F, typename A0>
-Event<> EventQueue::event(F f, A0 a0) {
-    return Event<>(this, f, a0);
+Event<void()> EventQueue::event(F f, A0 a0) {
+    return Event<void()>(this, f, a0);
 }
 
 template <typename F, typename A0, typename A1>
-Event<> EventQueue::event(F f, A0 a0, A1 a1) {
-    return Event<>(this, f, a0, a1);
+Event<void()> EventQueue::event(F f, A0 a0, A1 a1) {
+    return Event<void()>(this, f, a0, a1);
 }
 
 template <typename F, typename A0, typename A1, typename A2>
-Event<> EventQueue::event(F f, A0 a0, A1 a1, A2 a2) {
-    return Event<>(this, f, a0, a1, a2);
+Event<void()> EventQueue::event(F f, A0 a0, A1 a1, A2 a2) {
+    return Event<void()>(this, f, a0, a1, a2);
 }
 
 template <typename F, typename A0, typename A1, typename A2, typename A3>
-Event<> EventQueue::event(F f, A0 a0, A1 a1, A2 a2, A3 a3) {
-    return Event<>(this, f, a0, a1, a2, a3);
+Event<void()> EventQueue::event(F f, A0 a0, A1 a1, A2 a2, A3 a3) {
+    return Event<void()>(this, f, a0, a1, a2, a3);
 }
 
 template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
-Event<> EventQueue::event(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
-    return Event<>(this, f, a0, a1, a2, a3, a4);
+Event<void()> EventQueue::event(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+    return Event<void()>(this, f, a0, a1, a2, a3, a4);
 }
 
 }
 
-#endif
+#endif

EventQueue.h

@@ -37,7 +37,7 @@ namespace events {
 #define EVENTS_QUEUE_SIZE (32*EVENTS_EVENT_SIZE)
 
 // Predeclared classes
-template <typename A0, typename A1, typename A2, typename A3, typename A4>
+template <typename F>
 class Event;
 
 
@@ -329,31 +329,25 @@ class EventQueue {
      *  @return         Event that will dispatch on the specific queue
      */
     template <typename F>
-    Event<void, void, void, void, void>
-    event(F f);
+    Event<void()> event(F f);
 
     template <typename F, typename A0>
-    Event<void, void, void, void, void>
-    event(F f, A0 a0);
+    Event<void()> event(F f, A0 a0);
 
     template <typename F, typename A0, typename A1>
-    Event<void, void, void, void, void>
-    event(F f, A0 a0, A1 a1);
+    Event<void()> event(F f, A0 a0, A1 a1);
 
     template <typename F, typename A0, typename A1, typename A2>
-    Event<void, void, void, void, void>
-    event(F f, A0 a0, A1 a1, A2 a2);
+    Event<void()> event(F f, A0 a0, A1 a1, A2 a2);
 
     template <typename F, typename A0, typename A1, typename A2, typename A3>
-    Event<void, void, void, void, void>
-    event(F f, A0 a0, A1 a1, A2 a2, A3 a3);
+    Event<void()> event(F f, A0 a0, A1 a1, A2 a2, A3 a3);
 
     template <typename F, typename A0, typename A1, typename A2, typename A3, typename A4>
-    Event<void, void, void, void, void>
-    event(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4);
+    Event<void()> event(F f, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4);
 
 protected:
-    template <typename A0, typename A1, typename A2, typename A3, typename A4>
+    template <typename F>
     friend class Event;
     struct equeue _equeue;
     mbed::Callback<void(int)> _update;
@@ -767,4 +761,4 @@ namespace events {
 
 }
 
-#endif
+#endif

README.md

@@ -100,7 +100,7 @@ expect a callback.
 ``` cpp
 // Creates an event bound to the specified event queue
 EventQueue queue;
-Event<> event(&queue, doit);
+Event<void()> event(&queue, doit);
 
 // The event can be manually configured for special timing requirements
 // specified in milliseconds
@@ -113,7 +113,7 @@ queue.dispatch();
 
 // Events can also pass arguments to the underlying callback when both
 // initially constructed and posted.
-Event<int, int> event(&queue, printf, "recieved %d and %d\n");
+Event<void(int, int)> event(&queue, printf, "recieved %d and %d\n");
 
 // Events can be posted multiple times and enqueue gracefully until
 // the dispatch function is called.

TESTS/events/queue/main.cpp

@@ -174,12 +174,12 @@ void event_class_test() {
     counter = 0;
     EventQueue queue(2048);
 
-    Event<int, int, int, int, int> e5(&queue, count5);
-    Event<int, int, int, int> e4(&queue, count5, 1);
-    Event<int, int, int> e3(&queue, count5, 1, 1);
-    Event<int, int> e2(&queue, count5, 1, 1, 1);
-    Event<int> e1(&queue, count5, 1, 1, 1, 1);
-    Event<> e0(&queue, count5, 1, 1, 1, 1, 1);
+    Event<void(int, int, int, int, int)> e5(&queue, count5);
+    Event<void(int, int, int, int)> e4(&queue, count5, 1);
+    Event<void(int, int, int)> e3(&queue, count5, 1, 1);
+    Event<void(int, int)> e2(&queue, count5, 1, 1, 1);
+    Event<void(int)> e1(&queue, count5, 1, 1, 1, 1);
+    Event<void()> e0(&queue, count5, 1, 1, 1, 1, 1);
 
     e5.post(1, 1, 1, 1, 1);
     e4.post(1, 1, 1, 1);
@@ -197,12 +197,12 @@ void event_class_helper_test() {
     counter = 0;
     EventQueue queue(2048);
 
-    Event<> e5 = queue.event(count5, 1, 1, 1, 1, 1);
-    Event<> e4 = queue.event(count4, 1, 1, 1, 1);
-    Event<> e3 = queue.event(count3, 1, 1, 1);
-    Event<> e2 = queue.event(count2, 1, 1);
-    Event<> e1 = queue.event(count1, 1);
-    Event<> e0 = queue.event(count0);
+    Event<void()> e5 = queue.event(count5, 1, 1, 1, 1, 1);
+    Event<void()> e4 = queue.event(count4, 1, 1, 1, 1);
+    Event<void()> e3 = queue.event(count3, 1, 1, 1);
+    Event<void()> e2 = queue.event(count2, 1, 1);
+    Event<void()> e1 = queue.event(count1, 1);
+    Event<void()> e0 = queue.event(count0);
 
     e5.post();
     e4.post();