tcPendingAckWatchdog.h

Go to the documentation of this file.

/*
 * tcPendingAckWatchdog.h
 *
 *  Created on: Jan 10, 2018
 *      Author: mitydsp
 */
 
#ifndef TCPENDINGACKWATCHDOG_H_
#define TCPENDINGACKWATCHDOG_H_
 
#include <iostream>
#include <unordered_map>
#include <chrono>
#include <algorithm>
#include <mutex>
#include <vector>
 
#include "Utility/Timer.h"
 
namespace SocCamera {
 
class tcPendingAckWatcher {
public:
    tcPendingAckWatcher() {}
    virtual ~tcPendingAckWatcher() {}
 
    virtual void pendingAckNeeded(const void *id) = 0;
};
 
template<class IdType> class tcPendingAckWatchdog : tcTimedObject {
private:
    typedef std::chrono::steady_clock WatchdogClock;
 
public:
    tcPendingAckWatchdog() {
        // 50 ms timer interval time
        timer_interval = std::chrono::nanoseconds{50000000};
        if(!timer.initializeTimer()) {
        std::cout << "Error initializing timer object." << std::endl;
        }
    }
    virtual ~tcPendingAckWatchdog() { timer.stopTimer(); }
 
    void setTimeoutPeriod(std::chrono::microseconds duration) {
        mnDuration = std::chrono::microseconds{(int)(duration.count()*0.85f)};
    }
 
    void addWatcher(tcPendingAckWatcher* apWatcher) {
        std::lock_guard<std::mutex> guard(mutex);
        watchers.push_back(apWatcher);
    }
 
    void removeWatcher(tcPendingAckWatcher* apWatcher) {
        std::lock_guard<std::mutex> guard(mutex);
        auto it = std::find(watchers.begin(), watchers.end(), apWatcher);
        if(it != watchers.end())
            watchers.erase(it);
    }
 
    void newMessage(IdType id) {
        std::lock_guard<std::mutex> guard(mutex);
        ids[id] = WatchdogClock::now();
 
        if(!timer.isStarted()) {
            // start a 50 ms timer, repetitive
            timer.startTimer(this, 0, (uint32_t)timer_interval.count(), false);
        }
    }
 
    void messageDone(IdType id) {
        std::lock_guard<std::mutex> guard(mutex);
        ids.erase(id);
 
        // stop running the timer if we have no workers
        if(ids.size() == 0) {
            timer.stopTimer();
        }
    }
 
    virtual void timerTicked(tcTimer*) { this->timerTick(); };
 
protected:
    void timerTick() {
        std::lock_guard<std::mutex> guard(mutex);
        auto current = WatchdogClock::now();
        auto idIterator = ids.begin();
        while(idIterator != ids.end()) {
            auto delta = current - idIterator->second;
            if(delta > mnDuration) {
                // update notification time to now so we can fire again if needed
                idIterator->second = current;
                notifyWatchers(&idIterator->first);
            }
            idIterator++;
        }
    }
 
    void notifyWatchers(const void* apPtr) {
        auto it = watchers.begin();
        while(it != watchers.end()) {
            (*it)->pendingAckNeeded(apPtr);
            it++;
        }
    }
 
private:
    std::chrono::nanoseconds timer_interval; 
    std::vector<tcPendingAckWatcher*> watchers;                 
    std::unordered_map<IdType, WatchdogClock::time_point> ids;  
 
    std::chrono::microseconds mnDuration;                       
    tcTimer timer;     
 
    std::mutex mutex;  
};
 
} /* namespace SocCamera */
#endif /* TCPENDINGACKWATCHDOG_H_ */