overflow_policies.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <memory>
 
#include <kcenon/thread/core/error_handling.h>
#include <kcenon/thread/core/job.h>
 
namespace kcenon::thread::policies {
 
struct overflow_policy_tag {};
 
class overflow_reject_policy {
public:
    using policy_tag = overflow_policy_tag;
 
    [[nodiscard]] auto handle_overflow(std::unique_ptr<job>&& /*value*/)
        -> common::VoidResult {
        return common::error_info{-120, "queue is full, rejecting new item", "thread_system"};
    }
 
    [[nodiscard]] static constexpr auto blocks() noexcept -> bool {
        return false;
    }
 
    [[nodiscard]] static constexpr auto name() noexcept -> const char* {
        return "overflow_reject";
    }
};
 
class overflow_block_policy {
public:
    using policy_tag = overflow_policy_tag;
 
    [[nodiscard]] auto handle_overflow(std::unique_ptr<job>&& value)
        -> std::pair<common::VoidResult, std::unique_ptr<job>> {
        // Return the job back to the caller for retry after waiting
        return {common::error_info{-123, "queue full, waiting for space", "thread_system"},
                std::move(value)};
    }
 
    [[nodiscard]] static constexpr auto blocks() noexcept -> bool {
        return true;
    }
 
    [[nodiscard]] static constexpr auto name() noexcept -> const char* {
        return "overflow_block";
    }
};
 
class overflow_drop_oldest_policy {
public:
    using policy_tag = overflow_policy_tag;
 
    [[nodiscard]] auto handle_overflow(std::unique_ptr<job>&& value)
        -> std::pair<bool, std::unique_ptr<job>> {
        // Return true to indicate oldest should be dropped
        return {true, std::move(value)};
    }
 
    [[nodiscard]] static constexpr auto blocks() noexcept -> bool {
        return false;
    }
 
    [[nodiscard]] static constexpr auto drops_oldest() noexcept -> bool {
        return true;
    }
 
    [[nodiscard]] static constexpr auto name() noexcept -> const char* {
        return "overflow_drop_oldest";
    }
};
 
class overflow_drop_newest_policy {
public:
    using policy_tag = overflow_policy_tag;
 
    [[nodiscard]] auto handle_overflow(std::unique_ptr<job>&& /*value*/)
        -> common::VoidResult {
        // Silently drop the item
        return common::ok();
    }
 
    [[nodiscard]] static constexpr auto blocks() noexcept -> bool {
        return false;
    }
 
    [[nodiscard]] static constexpr auto drops_newest() noexcept -> bool {
        return true;
    }
 
    [[nodiscard]] static constexpr auto name() noexcept -> const char* {
        return "overflow_drop_newest";
    }
};
 
class overflow_timeout_policy {
public:
    using policy_tag = overflow_policy_tag;
 
    explicit overflow_timeout_policy(std::chrono::milliseconds timeout)
        : timeout_(timeout) {}
 
    overflow_timeout_policy() : timeout_(std::chrono::seconds(1)) {}
 
    [[nodiscard]] auto timeout() const noexcept -> std::chrono::milliseconds {
        return timeout_;
    }
 
    auto set_timeout(std::chrono::milliseconds timeout) noexcept -> void {
        timeout_ = timeout;
    }
 
    [[nodiscard]] auto handle_overflow(std::unique_ptr<job>&& value)
        -> std::pair<common::VoidResult, std::unique_ptr<job>> {
        return {common::error_info{-123, "queue full, waiting with timeout", "thread_system"},
                std::move(value)};
    }
 
    [[nodiscard]] static constexpr auto blocks() noexcept -> bool {
        return true;
    }
 
    [[nodiscard]] static constexpr auto name() noexcept -> const char* {
        return "overflow_timeout";
    }
 
private:
    std::chrono::milliseconds timeout_;
};
 
} // namespace kcenon::thread::policies