coalesced_updater.hpp

Go to the documentation of this file.

#pragma once
 
// CoalescedUpdater — coalesce rapid updates to a single callback on the event thread.
// Thread-safe: can be triggered from any thread.
 
#include <algorithm>
#include <atomic>
#include <functional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::events {

class CoalescedUpdater {
public:
    CoalescedUpdater() = default;
    virtual ~CoalescedUpdater() = default;

    void request_update() {
        if (!pending_.exchange(true, std::memory_order_acq_rel)) {
            // First trigger since last handle — post to event thread
            post_to_event_thread();
        }
    }

    void cancel_update() {
        pending_.store(false, std::memory_order_release);
    }

    bool update_pending() const {
        return pending_.load(std::memory_order_acquire);
    }

    virtual void on_update() = 0;

    void process_pending() {
        if (pending_.exchange(false, std::memory_order_acq_rel)) {
            on_update();
        }
    }
 
private:
    std::atomic<bool> pending_{false};
 
    // Consumers should poll process_pending() from their event loop.
    void post_to_event_thread() {}
};

class LambdaCoalescedUpdater : public CoalescedUpdater {
public:
    explicit LambdaCoalescedUpdater(std::function<void()> callback)
        : callback_(std::move(callback)) {}
 
    void on_update() override {
        if (callback_) callback_();
    }
 
private:
    std::function<void()> callback_;
};

class MultiTimer {
public:
    MultiTimer() = default;
    virtual ~MultiTimer() = default;

    void start_timer(int timer_id, int interval_ms);

    void stop_timer(int timer_id);

    bool is_timer_running(int timer_id) const;

    virtual void timer_callback(int timer_id) = 0;

    void stop_all_timers();
 
private:
    struct TimerEntry {
        int id;
        int interval_ms;
        bool running = false;
    };
    std::vector<TimerEntry> timers_;
};

class ActionBroadcaster {
public:
    using ActionCallback = std::function<void(std::string_view action)>;

    void send_action(std::string_view action) {
        std::vector<std::pair<int, ActionCallback>> callbacks;
        callbacks.reserve(listeners_.size());
        for (const auto& [id, fn] : listeners_) {
            callbacks.push_back({id, fn});
        }
        for (auto& [id, fn] : callbacks) {
            if (fn && has_listener(id)) fn(action);
        }
    }

    int add_listener(ActionCallback fn) {
        int id = next_id_++;
        listeners_.push_back({id, std::move(fn)});
        return id;
    }

    void remove_listener(int id) {
        listeners_.erase(
            std::remove_if(listeners_.begin(), listeners_.end(),
                          [id](auto& p) { return p.first == id; }),
            listeners_.end());
    }
 
private:
    std::vector<std::pair<int, ActionCallback>> listeners_;
    int next_id_ = 0;
 
    bool has_listener(int id) const {
        return std::any_of(listeners_.begin(), listeners_.end(),
                          [id](const auto& p) { return p.first == id; });
    }
};

class ScopedLowPowerModeDisabler {
public:
    ScopedLowPowerModeDisabler();
    ~ScopedLowPowerModeDisabler();
 
    ScopedLowPowerModeDisabler(const ScopedLowPowerModeDisabler&) = delete;
    ScopedLowPowerModeDisabler& operator=(const ScopedLowPowerModeDisabler&) = delete;
 
private:
    bool active_ = false;
};
 
 
 
}  // namespace pulp::events