finish test 1 (succesfully)

src/simplified/xf/core/behavior.cpp

@@ -6,11 +6,13 @@
 // TODO done: Implement code for XFBehavior class
 
 XFBehavior::XFBehavior() {
-
+    this->deleteOnTerminate_ = false;
 }
 
 XFBehavior::~XFBehavior() {
-
+    if (this->deleteOnTerminate()) {
+        delete this;
+    }
 }
 
 void XFBehavior::startBehavior() {
@@ -18,20 +20,22 @@ void XFBehavior::startBehavior() {
 }
 
 void XFBehavior::pushEvent(XFEvent *pEvent) {
+    if(pEvent->getBehavior()==nullptr) {
         pEvent->setBehavior(this);
+    }
     this->getDispatcher()->pushEvent(pEvent);
 }
 
 bool XFBehavior::deleteOnTerminate() const {
-    return deleteOnTerminate_;
+    return this->deleteOnTerminate_;
 }
 
 void XFBehavior::setDeleteOnTerminate(bool deleteBehaviour) {
-    deleteOnTerminate_ = deleteBehaviour;
+    this->deleteOnTerminate_ = deleteBehaviour;
 }
 
 const XFEvent *XFBehavior::getCurrentEvent() const {
-    return pCurrentEvent_;
+    return this->pCurrentEvent_;
 }
 
 interface::XFDispatcher *XFBehavior::getDispatcher() {
@@ -40,23 +44,26 @@ interface::XFDispatcher *XFBehavior::getDispatcher() {
 
 const XFTimeout *XFBehavior::getCurrentTimeout() {
     if(pCurrentEvent_->getEventType() == XFEvent::Timeout) {
-        return (XFTimeout*) pCurrentEvent_;
+        return (XFTimeout*) this->pCurrentEvent_;
     } else {
         return nullptr;
     }
 }
 
 void XFBehavior::setCurrentEvent(const XFEvent *pEvent) {
-    pCurrentEvent_ = pEvent;
+    this->pCurrentEvent_ = pEvent;
 }
 
 XFBehavior::TerminateBehavior XFBehavior::process(const XFEvent *pEvent) {
-    setCurrentEvent(pEvent);
+    this->setCurrentEvent(pEvent);
     XFEventStatus status = XFEventStatus::Unknown;
-    status = processEvent();
+    status = this->processEvent();
-    if(status == XFEventStatus::Consumed) {
+    if(status == XFEventStatus::Consumed && pEvent->deleteAfterConsume()) {
-        return deleteOnTerminate_;
+        delete pEvent;
-    } else {
-        return false;
     }
+    XFBehavior::TerminateBehavior terminateBehavior = false;
+    if(status == XFEventStatus::Terminate) {
+        terminateBehavior = true;
+    }
+    return terminateBehavior;
 }

src/simplified/xf/core/timeout.cpp

@@ -4,6 +4,7 @@
 
 XFTimeout::XFTimeout(int id, int interval, interface::XFBehavior *pBehavior):
     XFEvent(XFEventType::Timeout, id), interval_(interval) {
+    this->setRelTicks(this->getInterval());
     setBehavior(pBehavior);
 }
 

src/simplified/xf/port/common/dispatcher.cpp

@@ -24,10 +24,9 @@ interface::XFDispatcher * interface::XFDispatcher::getInstance() {
     return &dispatcher;
 }
 
-// TODO: Implement code for XFDispatcher class
+// TODO done: Implement code for XFDispatcher class
 
 XFDispatcher::XFDispatcher() {
-
 }
 
 XFDispatcher::~XFDispatcher() {
@@ -35,14 +34,20 @@ XFDispatcher::~XFDispatcher() {
 }
 
 void XFDispatcher::dispatchEvent(const XFEvent *pEvent) const {
-    if(pEvent->getBehavior()->process(pEvent)) { // TODO look weird
+    //Trace::out("[DEBUG] - Dispatch Event");
-        //events_.pop();
+    XFBehavior::TerminateBehavior terminateBehavior;
+    terminateBehavior = pEvent->getBehavior()->process(pEvent);
+    if(terminateBehavior) {
+        delete pEvent->getBehavior();
+        if(pEvent->deleteAfterConsume()) {
             delete pEvent;
         }
+    }
 }
 
 void XFDispatcher::pushEvent(XFEvent *pEvent) {
-    events_.push(pEvent);
+    //Trace::out("[DEBUG] - Push Event");
+    events_.push(pEvent, false);
 }
 
 void XFDispatcher::scheduleTimeout(int timeoutId, int interval, interface::XFBehavior *pBehavior) {
@@ -54,15 +59,16 @@ void XFDispatcher::unscheduleTimeout(int timeoutId, interface::XFBehavior *pBeha
 }
 
 void XFDispatcher::executeOnce() {
-    //XFEvent* event;
+    if(!this->events_.empty()) {
-    dispatchEvent(events_.front());
+        dispatchEvent(this->events_.front());
-    events_.pop();
+        this->events_.pop();
+    }
 
 }
 
 int XFDispatcher::execute(const void *param) {
     while(true){
-        executeOnce();
+        this->executeOnce();
     }
 }
 

src/simplified/xf/port/common/timeoutmanager.cpp

@@ -8,6 +8,9 @@
 #include "xf/interface/behavior.h"
 #include "xf/interface/mutex.h"
 #include "timeoutmanager.h"
+#if defined(XF_TRACE_EVENT_PUSH_POP) && (XF_TRACE_EVENT_PUSH_POP != 0)
+    #include "trace/trace.h"
+#endif // XF_TRACE_EVENT_PUSH_POP
 
 using Mutex = interface::XFMutex;       // Rename XFMutex interface class to Mutex for easier use.
 
@@ -24,6 +27,7 @@ interface::XFTimeoutManager * interface::XFTimeoutManager::getInstance() {
 // TODO done: Implement code for XFTimeoutManager class
 
 XFTimeoutManager::XFTimeoutManager() {
+    this->pMutex_ = interface::XFMutex::create();
 }
 
 XFTimeoutManager::~XFTimeoutManager() {
@@ -31,41 +35,63 @@ XFTimeoutManager::~XFTimeoutManager() {
 }
 
 void XFTimeoutManager::addTimeout(XFTimeout *pNewTimeout) {
-    pMutex_->lock();
+    this->pMutex_->lock();
-    timeouts_.push_front(pNewTimeout);
+    this->timeouts_.push_front(pNewTimeout);
-    pMutex_->unlock();
+    this->pMutex_->unlock();
 
 }
 
 void XFTimeoutManager::returnTimeout(XFTimeout *pTimeout) {
-    pMutex_->lock();
+    this->pMutex_->lock();
     XFDispatcher::getInstance()->pushEvent(pTimeout);
-    timeouts_.remove(pTimeout);
+    this->timeouts_.remove(pTimeout);
-    pMutex_->unlock();
+    this->pMutex_->unlock();
 }
 
 void XFTimeoutManager::start(std::function<void (uint32_t)> startTimeoutManagerTimer) {
-    startTimeoutManagerTimer(tickInterval_);
+    startTimeoutManagerTimer(this->tickInterval_);
 }
 
 void XFTimeoutManager::scheduleTimeout(int32_t timeoutId, int32_t interval, interface::XFBehavior *pBehavior) {
+    string str = "[DEBUG] - Schedule Timeout: ";
+    str += to_string(timeoutId);
+    //Trace::out(str);
     ::XFTimeout* timeout = new XFTimeout(timeoutId, interval, pBehavior);
     addTimeout(timeout);
 }
 
 void XFTimeoutManager::unscheduleTimeout(int32_t timeoutId, interface::XFBehavior *pBehavior) {
-    for(XFTimeout* timeout : timeouts_) {
+    string str = "[DEBUG] - Unschedule Timeout: ";
-        bool id = ( timeout->getId() == timeoutId );
+    str += to_string(timeoutId);
-        bool behavior = ( timeout->getBehavior() == pBehavior);
+    //Trace::out(str);
-        if( id && behavior ) {
+    this->pMutex_->lock();
-            timeouts_.remove(timeout);
+    TimeoutList::iterator it;
+    for(it = this->timeouts_.begin(); it != this->timeouts_.end(); it++){
+
+        if((*it)->getId()==timeoutId && (*it)->getBehavior() == pBehavior) {
+            it = this->timeouts_.erase(it);
         }
+
     }
+    this->pMutex_->unlock();
 }
 
 void XFTimeoutManager::tick() {
-    for(XFTimeout* timeout : timeouts_) {
+    //Trace::out("[DEBUG] - Tick");
-        timeout->substractFromRelTicks(tickInterval_);
+    if(!this->timeouts_.empty()) {
+        TimeoutList::iterator it;
+
+        this->pMutex_->lock();
+        for(it=this->timeouts_.begin(); it != this->timeouts_.end(); it++) {
+            if((*it)->getRelTicks() > 0) {
+                (*it)->substractFromRelTicks(this->tickInterval_);
+            } else {
+                XFEvent* ev = *(it);
+                XFDispatcher::getInstance()->pushEvent(ev);
+                it = this->timeouts_.erase(it);
+            }
+        }
+        this->pMutex_->unlock();
     }
 }