First cut at one-shot event handlers.

This is potentially pretty inefficient. It mallocs up storage for the
EventHandler, and frees is again after it fires. It also uses addHandler
and removeHandler which are both O(n). In practice, this may all be good
enough.

AikoEvents.cpp

@@ -3,6 +3,8 @@
 #include <stdlib.h>
 #include <wiring.h>
 
+#include <iostream>
+
 namespace Aiko {
 
   /* EventHanderList */
@@ -49,7 +51,7 @@ namespace Aiko {
   }
 
   void EventHandlerList::resetIterator() {
-    nextHandler_    = firstHandler_;
+    nextHandler_ = firstHandler_;
   }
 
 
@@ -61,19 +63,38 @@ namespace Aiko {
     handlerList_.add(handler);
   }
 
-  void EventManager::addHandler(void (*handlerFunction)(), unsigned int interval) {
+  void EventManager::addHandler(void (*handlerFunction)(), unsigned int period, unsigned int delay) {
     EventHandler* handler = static_cast<EventHandler*>(malloc(sizeof(EventHandler)));
-    handler->interval_ = interval;
-    handler->handler_  = handlerFunction;
-    handler->counter_  = 0;
+    handler->handler_   = handlerFunction;
+    handler->period_    = period;
+    handler->countdown_ = delay;
     addHandler(handler);
   }
 
+  void EventManager::addOneShotHandler(void (*handlerFunction)(), unsigned int delay) {
+    addHandler(handlerFunction, 0, delay);
+  }
+
   void EventManager::loop(unsigned long time) {
     if (!isRunning_) start(time);
-    unsigned long elapsed = time - lastLoopTime_;
+    long elapsed = time - lastLoopTime_;
+
+    handlerList_.resetIterator();
+    while (EventHandler* handler = handlerList_.next()) handler->countdown_ -= elapsed;
+
     handlerList_.resetIterator();
-    while (EventHandler* handler = handlerList_.next()) handler->loop(elapsed);
+    while (EventHandler* handler = handlerList_.next()) {
+      if (handler->countdown_ <= 0) {
+        handler->fire();
+        if (handler->period_ > 0)
+          handler->countdown_ += handler->period_;
+        else {
+          removeHandler(handler);
+          free(handler);
+        }
+      }
+    }
+
     lastLoopTime_ = time;
   }
 

AikoEvents.h

@@ -8,18 +8,12 @@ using namespace std;
 namespace Aiko {
 
   struct EventHandler {
-    void loop(unsigned int elapsed) {
-      if (counter_ <= elapsed) {
-        counter_ += interval_;
-        (*handler_)();
-      }
-      counter_ -= elapsed;
-    }
-
-    unsigned int interval_;
     void (*handler_)();
-    unsigned int counter_;
+    unsigned int period_;
+    long countdown_;
     struct EventHandler* next_;
+
+    void fire() { (*handler_)(); }
   };
 
   class EventHandlerList {
@@ -43,13 +37,16 @@ namespace Aiko {
     public:
       EventManager() { reset(); }
       void addHandler(EventHandler* handler);
-      void addHandler(void (*handler)(), unsigned int interval);
+      void addHandler(void (*handler)(), unsigned int interval, unsigned int delay = 0);
+      void addOneShotHandler(void (*handler)(), unsigned int delay);
       void loop(unsigned long time = Timing.millis());
       void removeHandler(EventHandler* handler);
       void reset();
 
     private:
       void start(unsigned long time);
+      void loopRepeatingHandler(EventHandler* handler);
+      void loopOneShotHandler(EventHandler* handler);
 
       bool              isRunning_;
       unsigned long     lastLoopTime_;

AikoSExpression.cpp

@@ -4,6 +4,7 @@
 namespace Aiko {
 
   char* SExpression::scan(char* head, char* tail, SExpression* expression) {
+    if (expression) expression->head_ = expression->tail_ = 0;
     char* s = skipWhitespace(head, tail);
     if (s < tail) {
       switch(*s) {

docs/Events.markdown

@@ -34,6 +34,14 @@ will be called after readTemperature() but before logData(). This
 ensures the execution order of functions is always predictable.
 
 
+### Events.addOneShotHandler
+
+Adds a handler that will be called once after a specified delay (in
+milliseconds). For example, to invoke myFunction in 1 second, call:
+
+    Events.addOneShotHandler(myFunction, 1000):
+
+
 ### Events.loop
 
 To cause event handlers specified using addHandler to be executed the

tests/EventManagerTest.h

@@ -24,4 +24,14 @@ class EventManagerTests : public CxxTest::TestSuite {
     }
   }
 
+  void test_should_call_a_one_shot_handler_just_once() {
+    Events.addOneShotHandler(testHandler, 1000);
+    Events.loop(0);
+    TS_ASSERT_EQUALS(handlerCallCount, 0);
+    Events.loop(1000);
+    TS_ASSERT_EQUALS(handlerCallCount, 1);
+    Events.loop(2000);
+    TS_ASSERT_EQUALS(handlerCallCount, 1);
+  }
+
 };

tests/SExpressionTest.h

@@ -53,8 +53,8 @@ class SExpressionTests : public CxxTest::TestSuite {
 
     SExpression expression;
     char *s = expression.scan(a, b);
-    TS_ASSERT_EQUALS(expression.head(), (char*)0);
-    TS_ASSERT_EQUALS(expression.tail(), (char*)0);
+    TS_ASSERT(expression.head() == (char*)0);
+    TS_ASSERT(expression.tail() == (char*)0);
     TS_ASSERT_EQUALS(s, b);
   }