mirror of
https://github.com/TomHarte/CLK.git
synced 2024-08-26 06:29:04 +00:00
83 lines
2.4 KiB
C++
83 lines
2.4 KiB
C++
//
|
|
// ClockDeferrer.hpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 23/08/2018.
|
|
// Copyright © 2018 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#ifndef ClockDeferrer_h
|
|
#define ClockDeferrer_h
|
|
|
|
#include <functional>
|
|
#include <vector>
|
|
|
|
/*!
|
|
A ClockDeferrer maintains a list of ordered actions and the times at which
|
|
they should happen, and divides a total execution period up into the portions
|
|
that occur between those actions, triggering each action when it is reached.
|
|
*/
|
|
template <typename TimeUnit> class ClockDeferrer {
|
|
public:
|
|
/// Constructs a ClockDeferrer that will call target(period) in between deferred actions.
|
|
ClockDeferrer(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
|
|
|
|
/*!
|
|
Schedules @c action to occur in @c delay units of time.
|
|
|
|
Actions must be scheduled in the order they will occur. It is undefined behaviour
|
|
to schedule them out of order.
|
|
*/
|
|
void defer(TimeUnit delay, const std::function<void(void)> &action) {
|
|
pending_actions_.emplace_back(delay, action);
|
|
}
|
|
|
|
/*!
|
|
Runs for @c length units of time.
|
|
|
|
The constructor-supplied target will be called with one or more periods that add up to @c length;
|
|
any scheduled actions will be called between periods.
|
|
*/
|
|
void run_for(TimeUnit length) {
|
|
// If there are no pending actions, just run for the entire length.
|
|
// This should be the normal branch.
|
|
if(pending_actions_.empty()) {
|
|
target_(length);
|
|
return;
|
|
}
|
|
|
|
// Divide the time to run according to the pending actions.
|
|
while(length > TimeUnit(0)) {
|
|
TimeUnit next_period = pending_actions_.empty() ? length : std::min(length, pending_actions_[0].delay);
|
|
target_(next_period);
|
|
length -= next_period;
|
|
|
|
off_t performances = 0;
|
|
for(auto &action: pending_actions_) {
|
|
action.delay -= next_period;
|
|
if(!action.delay) {
|
|
action.action();
|
|
++performances;
|
|
}
|
|
}
|
|
if(performances) {
|
|
pending_actions_.erase(pending_actions_.begin(), pending_actions_.begin() + performances);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::function<void(TimeUnit)> target_;
|
|
|
|
// The list of deferred actions.
|
|
struct DeferredAction {
|
|
TimeUnit delay;
|
|
std::function<void(void)> action;
|
|
|
|
DeferredAction(TimeUnit delay, const std::function<void(void)> &action) : delay(delay), action(std::move(action)) {}
|
|
};
|
|
std::vector<DeferredAction> pending_actions_;
|
|
};
|
|
|
|
#endif /* ClockDeferrer_h */
|