Update EventQueue API to use chrono times

Main dispatch function is updated to take a Chrono duration instead
of an integer milliseconds parameter.

To allow for the instances of blocking and non wait versions, which
previously were actioned by passing either -1 or 0 as the millisecond
delay respectively, two other functions are now available.

dispatch_once() - new
dispatch_forever() - modified from the original version

Author: adbridge

events/include/events/EventQueue.h

@@ -89,30 +89,28 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     /** Dispatch events
      *
      *  Executes events until the specified milliseconds have passed.
-     *  If ms is negative, the dispatch function will dispatch events
-     *  indefinitely or until break_dispatch is called on this queue.
      *
-     *  When called with a finite timeout, the dispatch function is guaranteed
-     *  to terminate. When called with a timeout of 0, the dispatch function
-     *  does not wait and is IRQ safe.
+     *  The dispatch function is guaranteed to terminate after the elapsed wait
      *
-     *  @param ms       Time to wait for events in milliseconds, a negative
-     *                  value will dispatch events indefinitely
-     *                  (default to -1)
+     *  @param wait     Time to wait for events in milliseconds, expressed as a 
+     *                  Chrono duration.
      */
-    void dispatch(int ms = -1);
+    void dispatch(duration wait);
 
     /** Dispatch events without a timeout
-     *
-     *  This is equivalent to EventQueue::dispatch with no arguments, but
-     *  avoids overload ambiguities when passed as a callback.
-     *
-     *  @see EventQueue::dispatch
+     * 
+     * Executes events indefinitely unless the dispatch loop is forcibly broken.
+     * See break_dispatch()
+     * 
      */
-    void dispatch_forever()
-    {
-        dispatch();
-    }
+    void dispatch_forever();
+
+    /** Dispatch currently queued events only and then terminate
+     * 
+     * In this case, the dispatch function does not wait and is IRQ safe.
+     * 
+     */
+    void dispatch_once();
 
     /** Break out of a running event loop
      *

events/source/EventQueue.cpp

@@ -41,9 +41,19 @@ EventQueue::~EventQueue()
     equeue_destroy(&_equeue);
 }
 
-void EventQueue::dispatch(int ms)
+void EventQueue::dispatch(duration wait)
 {
-    return equeue_dispatch(&_equeue, ms);
+    return equeue_dispatch(&_equeue, wait.count());
+}
+
+void EventQueue::dispatch_forever()
+{
+    return equeue_dispatch(&_equeue, -1);
+}
+
+void EventQueue::dispatch_once()
+{
+    return equeue_dispatch(&_equeue, 0);
 }
 
 void EventQueue::break_dispatch()