CallbackClock

CallbackClock.cpp

@@ -0,0 +1,59 @@
+#include "CallbackClock.h"
+
+namespace midi {
+
+CallbackClock::CallbackClock()
+    : CallbackClock(0, 0)
+{
+}
+
+CallbackClock::CallbackClock(TickCallback tickCallback)
+    : CallbackClock(tickCallback, 0)
+{
+}
+
+CallbackClock::CallbackClock(TickCallback callback, void* callbackData)
+    : tickCallback(callback), tickCallbackData(callbackData)
+{
+}
+
+CallbackClock::TickCallback CallbackClock::getTickCallback()
+{
+    tickCallback_mutex.lock();
+    TickCallback c = tickCallback;
+    tickCallback_mutex.unlock();
+    return c;
+}
+
+void CallbackClock::setTickCallback(TickCallback c)
+{
+    tickCallback_mutex.lock();
+    tickCallback = c;
+    tickCallback_mutex.unlock();
+}
+
+void* CallbackClock::getTickCallbackData()
+{
+    tickCallbackData_mutex.lock();
+    void* d = tickCallbackData;
+    tickCallbackData_mutex.unlock();
+    return d;
+}
+
+void CallbackClock::setTickCallbackData(void* d)
+{
+    tickCallbackData_mutex.lock();
+    tickCallbackData = d;
+    tickCallbackData_mutex.unlock();
+}
+
+void CallbackClock::tick()
+{
+    TickCallback c = getTickCallback();
+    if(c) {
+        c(getTickCallbackData());
+    }
+}
+
+
+};

CallbackClock.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "Clock.h"
+
+namespace midi {
+
+class CallbackClock : public Clock
+{
+public:
+    typedef void (*TickCallback)( void *userData );
+
+private:    
+    TickCallback tickCallback;
+    std::mutex tickCallback_mutex;
+    void* tickCallbackData;
+    std::mutex tickCallbackData_mutex;
+
+public:
+    CallbackClock();
+    CallbackClock(TickCallback tickCallback);
+    CallbackClock(TickCallback tickCallback, void* tickCallbackData);
+    TickCallback getTickCallback();
+    void setTickCallback(TickCallback tickCallback);
+    void* getTickCallbackData();
+    void setTickCallbackData(void* tickCallbackData);
+
+public:
+    virtual void tick();
+};
+
+} // namespace

Clock.h

@@ -4,8 +4,6 @@
 #include <thread>
 #include <chrono>
 
-#include <iostream>
-
 namespace midi {
 
 class Clock

tests/CMakeLists.txt

@@ -18,3 +18,6 @@ target_link_libraries(launchpad-screen midi)
 
 add_executable(clock clock.cpp)
 target_link_libraries(clock midi) 
+
+add_executable(callback-clock callback-clock.cpp)
+target_link_libraries(callback-clock midi) 

tests/callback-clock.cpp

@@ -0,0 +1,37 @@
+#include "CallbackClock.h"
+#include <iostream>
+
+using namespace std;
+
+void tick(void* data)
+{
+    cout << (const char*)data << endl;
+}
+
+const char* txt = "tick tack";
+
+int main()
+{
+    midi::CallbackClock c(&tick, (void*)txt);
+    c.setBpm(60);
+    
+    cout << "initialized" << txt << (void*)txt << endl;
+
+    c.tick();
+    c.tick();
+
+    c.start();
+    cout << "started" << endl;
+
+    while(true) {
+        midi::CallbackClock::bpm_type bpm;
+        cin >> bpm;
+        if(bpm == 0) {
+            c.stop();
+            break;
+        }
+        c.setBpm(bpm);
+    }
+
+    return 0;
+}

tests/clock.cpp

@@ -0,0 +1,33 @@
+#include "Clock.h"
+#include <iostream>
+
+using namespace std;
+
+class TestClock : public midi::Clock
+{
+protected:
+    virtual void tick() 
+    {
+        cout << now().time_since_epoch().count() / 1000000  << " tick" << endl;
+    }
+};
+
+int main()
+{
+    TestClock c;
+    c.setBpm(60);
+
+    c.start();
+
+    while(true) {
+        TestClock::bpm_type bpm;
+        cin >> bpm;
+        if(bpm == 0) {
+            c.stop();
+            break;
+        }
+        c.setBpm(bpm);
+    }
+
+    return 0;
+}