failure_window.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <algorithm>
#include <chrono>
#include <deque>
#include <mutex>
 
namespace kcenon::common::resilience {
 
class failure_window {
public:
    using clock_type = std::chrono::steady_clock;
    using time_point = clock_type::time_point;
    using duration = std::chrono::milliseconds;
 
    explicit failure_window(duration window_duration)
        : window_duration_(window_duration)
    {
    }
 
    auto record_failure() -> void
    {
        std::lock_guard<std::mutex> lock(mutex_);
        failures_.push_back(clock_type::now());
    }
 
    [[nodiscard]] auto get_failure_count() const -> std::size_t
    {
        std::lock_guard<std::mutex> lock(mutex_);
        cleanup_expired_failures();
        return failures_.size();
    }
 
    auto reset() -> void
    {
        std::lock_guard<std::mutex> lock(mutex_);
        failures_.clear();
    }
 
    [[nodiscard]] auto is_empty() -> bool
    {
        std::lock_guard<std::mutex> lock(mutex_);
        cleanup_expired_failures();
        return failures_.empty();
    }
 
private:
    auto cleanup_expired_failures() const -> void
    {
        const auto now = clock_type::now();
        const auto cutoff = now - window_duration_;
 
        // Remove all failures older than cutoff
        failures_.erase(
            std::remove_if(failures_.begin(), failures_.end(),
                [cutoff](const time_point& t) { return t < cutoff; }),
            failures_.end());
    }
 
    duration window_duration_;
    mutable std::deque<time_point> failures_;
    mutable std::mutex mutex_;
};
 
} // namespace kcenon::common::resilience