Trigger.hpp

 
#include <type_traits>
 
#pragma once
 
namespace tt {
 
template<typename Clock>
class Trigger {
    using clock = Clock;
    using rep = typename clock::rep;
    using time_point = typename clock::time_point;
 
    struct trigger_t {
        rep time_point;
        int level;
    };
 
    Trigger *parent;
 
    std::atomic<trigger_t> event;
 
public:
    Trigger(Trigger *parent=nullptr) noexcept :
        parent(parent), event({std::numeric_limits<rep>::max(), 0}) {}
 
    Trigger(Trigger const &) noexcept = delete;
    Trigger(Trigger &&) noexcept = delete;
    Trigger &operator=(Trigger const &) noexcept = delete;
    Trigger &operator=(Trigger &&) noexcept = delete;
    ~Trigger() = default;
 
    Trigger &add(time_point time_point, int level) noexcept {
        tt_assume(level > 0);
 
        auto old_event = event.load();
        trigger_t new_event;
        do {
            new_event = trigger_t{
                std::min(old_event.time_point, time_point.time_since_epoch().count()),
                std::max(old_event.level, level)
            };
 
        } while (!event.compare_exchange_strong(old_event, new_event));
 
        if (parent) {
            parent->add(time_point, level);
        }
        return *this;
    }
 
    int check(time_point current_time) noexcept {
        auto old_event = event.load();
        trigger_t new_event;
        do {
            if (old_event.time_point > current_time.time_since_epoch().count()) {
                return 0;
            }
 
            // Set next trigger to the far future.
            new_event = trigger_t{std::numeric_limits<rep>::max(), 0};
        } while (!event.compare_exchange_strong(old_event, new_event));
 
        return old_event.level;
    }
 
    Trigger &operator++() noexcept {
        return add(time_point::min(), 1);
    }
 
    Trigger &operator+=(time_point time_point) noexcept {
        return add(time_point, 1);
    }
 
    template<typename T, std::enable_if_t<std::is_arithmetic_v<T>,int> = 0>
    Trigger &operator+=(T level) noexcept {
        return add(time_point::min(), static_cast<int>(level));
    }
 
};
 
}