Initial commit

src/xf/port/default/dispatcher-active.cpp

@@ -0,0 +1,139 @@
+#include <config/xf-config.h>
+
+#if (USE_XF_DISPATCHER_ACTIVE_DEFAULT_IMPLEMENTATION != 0)
+
+#include <cassert>
+#if defined(XF_TRACE_EVENT_PUSH_POP) && (XF_TRACE_EVENT_PUSH_POP != 0)
+    #include "trace/trace.h"
+#endif // XF_TRACE_EVENT_PUSH_POP
+#include "xf/eventstatus.h"
+#include "xf/interface/timeoutmanager.h"
+#include "xf/interface/reactive.h"
+#include "xf/interface/thread.h"
+#include "xf/interface/resourcefactory.h"
+#include "dispatcher-active.h"
+
+using interface::XFTimeoutManager;
+using interface::XFResourceFactory;
+using interface::XFReactive;
+
+XFDispatcherActiveDefault::XFDispatcherActiveDefault() :
+    isExecuting_(false),
+    pThread_(nullptr)
+{
+    // Create Thread
+    pThread_ = XFResourceFactory::getInstance()->createThread(this,
+                                                              interface::XFThread::EntryMethodBody(&XFDispatcherActiveDefault::execute),
+                                                              "dispatcherThread");
+    assert(pThread_);
+}
+
+XFDispatcherActiveDefault::~XFDispatcherActiveDefault()
+{
+    isExecuting_ = false;
+    pThread_->stop();
+
+    if (pThread_)
+    {
+        delete pThread_;
+    }
+}
+
+void XFDispatcherActiveDefault::start()
+{
+    assert(pThread_);
+    isExecuting_ = true;
+    pThread_->start();
+}
+
+void XFDispatcherActiveDefault::stop()
+{
+    isExecuting_ = false;
+    pThread_->stop();
+}
+
+void XFDispatcherActiveDefault::pushEvent(XFEvent * pEvent, bool fromISR)
+{
+#if defined(XF_TRACE_EVENT_PUSH_POP) && (XF_TRACE_EVENT_PUSH_POP != 0)
+        Trace::out("Push event: 0x%x", pEvent);
+#endif // XF_TRACE_EVENT_PUSH_POP
+        events_.push(pEvent, fromISR);
+}
+
+void XFDispatcherActiveDefault::scheduleTimeout(int timeoutId, int interval, interface::XFReactive * pReactive)
+{
+    // Forward timeout to the timeout manager
+    XFTimeoutManager::getInstance()->scheduleTimeout(timeoutId, interval, pReactive);
+}
+
+void XFDispatcherActiveDefault::unscheduleTimeout(int timeoutId, interface::XFReactive * pReactive)
+{
+    // Forward timeout to the timeout manager
+    XFTimeoutManager::getInstance()->unscheduleTimeout(timeoutId, pReactive);
+}
+
+int XFDispatcherActiveDefault::execute(const void * param /* = nullptr */)
+{
+    (void)param;
+
+    while(isExecuting_)
+    {
+        while (events_.empty() && isExecuting_)
+        {
+            events_.pend();	// Wait until something to do
+        }
+
+        executeOnce();
+    }
+
+    return 0;
+}
+
+int XFDispatcherActiveDefault::executeOnce()
+{
+    if (!events_.empty())
+    {
+        const XFEvent * pEvent;
+
+        // Deque next event from queue
+        pEvent = events_.front(); events_.pop();
+#if defined(XF_TRACE_EVENT_PUSH_POP) && (XF_TRACE_EVENT_PUSH_POP != 0)
+            Trace::out("Pop event:  0x%x", pEvent);
+#endif // XF_TRACE_EVENT_PUSH_POP
+
+        if (pEvent)
+        {
+            // Forward the event to the behavioral class
+            dispatchEvent(pEvent);
+
+            if (pEvent->getEventType() == XFEvent::Terminate)
+            {
+                // Exit the event loop
+                isExecuting_ = false;
+            }
+
+            if (pEvent->deleteAfterConsume())
+            {
+                // Remove the consumed event
+                delete pEvent;
+            }
+        }
+    }
+
+    return isExecuting_;
+}
+
+void XFDispatcherActiveDefault::dispatchEvent(const XFEvent * pEvent) const
+{
+    XFReactive::TerminateBehavior terminateBehavior;
+
+    terminateBehavior = pEvent->getBehavior()->process(pEvent);
+
+    // Check if behavior should be deleted
+    if (terminateBehavior and pEvent->getBehavior()->deleteOnTerminate())
+    {
+        delete pEvent->getBehavior();
+    }
+}
+
+#endif // USE_XF_DISPATCHER_ACTIVE_DEFAULT_IMPLEMENTATION