bound_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 <cstddef>
#include <limits>
#include <optional>
 
namespace kcenon::thread::policies {
 
struct bound_policy_tag {};
 
class unbounded_policy {
public:
    using policy_tag = bound_policy_tag;
 
    constexpr unbounded_policy() noexcept = default;
 
    [[nodiscard]] constexpr auto is_full(std::size_t /*current_size*/) const noexcept -> bool {
        return false;
    }
 
    [[nodiscard]] constexpr auto max_size() const noexcept -> std::optional<std::size_t> {
        return std::nullopt;
    }
 
    [[nodiscard]] static constexpr auto is_bounded() noexcept -> bool {
        return false;
    }
 
    [[nodiscard]] constexpr auto remaining_capacity(std::size_t /*current_size*/) const noexcept -> std::size_t {
        return std::numeric_limits<std::size_t>::max();
    }
};
 
class bounded_policy {
public:
    using policy_tag = bound_policy_tag;
 
    explicit constexpr bounded_policy(std::size_t max) noexcept
        : max_size_(max) {}
 
    [[nodiscard]] constexpr auto is_full(std::size_t current_size) const noexcept -> bool {
        return current_size >= max_size_;
    }
 
    [[nodiscard]] constexpr auto max_size() const noexcept -> std::optional<std::size_t> {
        return max_size_;
    }
 
    [[nodiscard]] static constexpr auto is_bounded() noexcept -> bool {
        return true;
    }
 
    [[nodiscard]] constexpr auto remaining_capacity(std::size_t current_size) const noexcept -> std::size_t {
        if (current_size >= max_size_) {
            return 0;
        }
        return max_size_ - current_size;
    }
 
    auto set_max_size(std::size_t new_max) noexcept -> void {
        max_size_ = new_max;
    }
 
private:
    std::size_t max_size_;
};
 
class dynamic_bounded_policy {
public:
    using policy_tag = bound_policy_tag;
 
    explicit constexpr dynamic_bounded_policy(
        std::optional<std::size_t> max = std::nullopt) noexcept
        : max_size_(max) {}
 
    [[nodiscard]] constexpr auto is_full(std::size_t current_size) const noexcept -> bool {
        if (!max_size_.has_value()) {
            return false;
        }
        return current_size >= max_size_.value();
    }
 
    [[nodiscard]] constexpr auto max_size() const noexcept -> std::optional<std::size_t> {
        return max_size_;
    }
 
    [[nodiscard]] constexpr auto is_bounded() const noexcept -> bool {
        return max_size_.has_value();
    }
 
    [[nodiscard]] constexpr auto remaining_capacity(std::size_t current_size) const noexcept -> std::size_t {
        if (!max_size_.has_value()) {
            return std::numeric_limits<std::size_t>::max();
        }
        if (current_size >= max_size_.value()) {
            return 0;
        }
        return max_size_.value() - current_size;
    }
 
    auto set_max_size(std::size_t new_max) noexcept -> void {
        max_size_ = new_max;
    }
 
    auto set_unbounded() noexcept -> void {
        max_size_ = std::nullopt;
    }
 
private:
    std::optional<std::size_t> max_size_;
};
 
} // namespace kcenon::thread::policies