staged_transition.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <cstdint>
 
namespace pulp::signal {
 
class StagedTransition {
public:
    static constexpr int due_steps(int total, std::int64_t elapsed,
                                   std::int64_t horizon) noexcept {
        if (total <= 0) return 0;
        if (horizon <= 0 || elapsed >= horizon) return total;
        if (elapsed <= 0) return 0;
        const std::int64_t num = static_cast<std::int64_t>(total) * elapsed;
        return static_cast<int>((num + horizon - 1) / horizon);
    }

    void begin(int total_steps) noexcept {
        total_ = std::max(total_steps, 0);
        done_ = 0;
    }

    void cancel() noexcept {
        total_ = 0;
        done_ = 0;
    }

    template <typename Step>
    int run_due(std::int64_t elapsed, std::int64_t horizon, Step&& step) {
        return run_until(due_steps(total_, elapsed, horizon), step);
    }

    template <typename Step>
    int run_next(int count, Step&& step) {
        return run_until(done_ + std::max(count, 0), step);
    }

    template <typename Step>
    int finish_now(Step&& step) {
        return run_until(total_, step);
    }
 
    bool active() const noexcept { return done_ < total_; }
    int total() const noexcept { return total_; }
    int completed() const noexcept { return done_; }
    int remaining() const noexcept { return total_ - done_; }
 
private:
    template <typename Step>
    int run_until(int target, Step& step) {
        target = std::min(target, total_);
        const int start = done_;
        while (done_ < target) {
            const int index = done_;
            ++done_; // advance first so a step may inspect remaining()
            step(index);
        }
        return done_ - start;
    }
 
    int total_ = 0;
    int done_ = 0;
};
 
} // namespace pulp::signal