async.h

Go to the documentation of this file.

#ifndef util_async_H
#define util_async_H
 
#include "conscience_util.h"
#include "system.h"
#include <ctime>
#include <future>
#include <mutex>
#include <condition_variable>
#include <thread>
 
using std::future, std::condition_variable, std::thread, std::mutex, std::future_status, std::lock_guard, std::chrono_literals::operator""ms, std::shared_ptr, std::make_shared;
 
using namespace conscience_utils::systemutils;
 
namespace conscience_utils::async {
 
template <typename TFutureResult>
inline bool isFutureDone(future<TFutureResult> &f) {
    return f.wait_for(0ms) == future_status::ready;
}
struct DebouceState {
    future<void> *futurePtr = nullptr;
    mutex futureMutex;
    unsigned long long expectedEndTimestampMillis;
};
 
template <typename... TArgs>
function<void(TArgs...)> debounce(function<void(TArgs...)> f, int periodMillis) {
    auto state = make_shared<DebouceState>();
    function<void(TArgs...)> fn = [f, periodMillis, state](TArgs... args) {
        const lock_guard<mutex> lock(state->futureMutex);
 
        if (state->futurePtr != nullptr && isFutureDone(*state->futurePtr)) {
            delete state->futurePtr;
            state->futurePtr = nullptr;
        }
        if (state->futurePtr == nullptr) {
 
            auto callWithWait = std::bind(
                [&, f, periodMillis, state](TArgs... args) {
                    sleepMillis(periodMillis);
                    while (nowMillis() < state->expectedEndTimestampMillis) {
                        sleepMillis(state->expectedEndTimestampMillis - nowMillis());
                    }
                    f(args...);
                },
                args...);
            state->futurePtr = new future<void>(std::move(std::async(std::launch::async, callWithWait)));
        }
        state->expectedEndTimestampMillis = nowMillis() + periodMillis;
    };
    return fn;
}
 
class CscTimer {
public:
    CscTimer(double timeout);
    double elapsed();
    bool timeoutReached();
    void reset();
 
private:
    timespec beginTime, lastMeasuredTime;
    double timeout;
};
 
bool executeWithTimeout(const function<void()> &action, std::chrono::milliseconds timeoutMillis);
 
}
 
#endif