ControlPolicy.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // Distributed under the Boost Software License, Version 1.0.
// //    (See accompanying file LICENSE_1_0.txt or copy at
// //          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_CONTROL_POLICY_HPP
#define MIMICPP_CONTROL_POLICY_HPP
 
#pragma once
 
#include "mimic++/Reports.hpp"
#include "mimic++/Sequence.hpp"
#include "mimic++/Utility.hpp"
 
#include <cassert>
#include <limits>
#include <memory>
#include <optional>
#include <stdexcept>
#include <tuple>
#include <utility>
#include <vector>
 
namespace mimicpp::detail
{
    template <typename... Sequences>
    [[nodiscard]]
    constexpr std::tuple<std::tuple<std::shared_ptr<Sequences>, sequence::Id>...> make_sequence_entries(
        const std::tuple<std::shared_ptr<Sequences>...>& sequences
    ) noexcept
    {
        // This is a workaround due to some issues with clang-17 with c++23 and libstdc++
        // That configuration prevents the direct initialization, thus we have to default construct first and
        // setup afterwards. Compilers will probably detect that and optimize accordingly.
        std::tuple<std::tuple<std::shared_ptr<Sequences>, sequence::Id>...> result{};
        std::invoke(
            [&]<std::size_t... indices>([[maybe_unused]] const std::index_sequence<indices...>) noexcept
            {
                ((std::get<indices>(result) =
                std::tuple{
                    std::get<indices>(sequences),
                    std::get<indices>(sequences)->add(),
                }), ...);
            },
            std::index_sequence_for<Sequences...>{});
        return result;
    }
 
    class TimesConfig
    {
    public:
        [[nodiscard]]
        TimesConfig() = default;
 
        [[nodiscard]]
        constexpr TimesConfig(const int min, const int max)
        {
            if (min < 0
                || max < 0
                || max < min)
            {
                throw std::invalid_argument{
                    "min must be less or equal to max and both must not be less than zero."
                };
            }
 
            m_Min = min;
            m_Max = max;
        }
 
        [[nodiscard]]
        constexpr int min() const noexcept
        {
            return m_Min;
        }
 
        [[nodiscard]]
        constexpr int max() const noexcept
        {
            return m_Max;
        }
 
    private:
        int m_Min{1};
        int m_Max{1};
    };
}
 
namespace mimicpp
{
    namespace detail
    {
        [[nodiscard]]
        control_state_t make_control_state(
            const int min,
            const int max,
            const int count,
            const auto& sequenceEntries
        )
        {
            if (count == max)
            {
                return state_saturated{
                    .min = min,
                    .max = max,
                    .count = count,
                    .sequences = std::apply(
                        [](const auto&... entries)
                        {
                            return std::vector<sequence::Tag>{
                                std::get<0>(entries)->tag()...
                            };
                        },
                        sequenceEntries)
                };
            }
 
            std::vector<sequence::Tag> inapplicable{};
            std::vector<sequence::rating> ratings{};
            std::apply(
                [&](const auto&... entries)
                {
                    (...,
                        std::invoke(
                            [&](auto& seq, const sequence::Id id)
                            {
                                if (const std::optional priority = seq->priority_of(id))
                                {
                                    ratings.emplace_back(
                                        *priority,
                                        seq->tag());
                                }
                                else
                                {
                                    inapplicable.emplace_back(seq->tag());
                                }
                            },
                            std::get<0>(entries),
                            std::get<1>(entries)));
                },
                sequenceEntries);
 
            if (!std::ranges::empty(inapplicable))
            {
                return state_inapplicable{
                    .min = min,
                    .max = max,
                    .count = count,
                    .sequenceRatings = std::move(ratings),
                    .inapplicableSequences = std::move(inapplicable)
                };
            }
 
            return state_applicable{
                .min = min,
                .max = max,
                .count = count,
                .sequenceRatings = std::move(ratings),
            };
        }
    }
 
    template <typename... Sequences>
    class ControlPolicy
    {
    public:
        static constexpr std::size_t sequenceCount{sizeof...(Sequences)};
 
        [[nodiscard]]
        explicit constexpr ControlPolicy(
            const detail::TimesConfig& timesConfig,
            const sequence::detail::Config<Sequences...>& sequenceConfig
        ) noexcept
            : m_Min{timesConfig.min()},
            m_Max{timesConfig.max()},
            m_Sequences{
                detail::make_sequence_entries(sequenceConfig.sequences())
            }
        {
            update_sequence_states();
        }
 
        [[nodiscard]]
        constexpr bool is_satisfied() const noexcept
        {
            return m_Min <= m_Count
                    && m_Count <= m_Max;
        }
 
        [[nodiscard]]
        constexpr bool is_saturated() const noexcept
        {
            return m_Count == m_Max;
        }
 
        [[nodiscard]]
        constexpr bool is_applicable() const noexcept
        {
            return m_Count < m_Max
                    && std::apply(
                        [](const auto&... entries) noexcept
                        {
                            return (... && std::get<0>(entries)->is_consumable(std::get<1>(entries)));
                        },
                        m_Sequences);
        }
 
        constexpr void consume() noexcept
        {
            assert(is_applicable());
 
            std::apply(
                [](auto&... entries) noexcept
                {
                    (..., std::get<0>(entries)->consume(std::get<1>(entries)));
                },
                m_Sequences);
 
            ++m_Count;
 
            update_sequence_states();
        }
 
        [[nodiscard]]
        control_state_t state() const
        {
            return detail::make_control_state(
                m_Min,
                m_Max,
                m_Count,
                m_Sequences);
        }
 
    private:
        int m_Min;
        int m_Max;
        int m_Count{};
        std::tuple<
            std::tuple<std::shared_ptr<Sequences>, sequence::Id>...> m_Sequences{};
 
        constexpr void update_sequence_states() noexcept
        {
            if (m_Count == m_Min)
            {
                std::apply(
                    [](auto&... entries) noexcept
                    {
                        (..., std::get<0>(entries)->set_satisfied(std::get<1>(entries)));
                    },
                    m_Sequences);
            }
            else if (m_Count == m_Max)
            {
                std::apply(
                    [](auto&... entries) noexcept
                    {
                        (..., std::get<0>(entries)->set_saturated(std::get<1>(entries)));
                    },
                    m_Sequences);
            }
        }
    };
}
 
namespace mimicpp::expect
{
    [[nodiscard]]
    constexpr auto times(const int min, const int max)
    {
        return detail::TimesConfig{min, max};
    }
 
    [[nodiscard]]
    constexpr auto times(const int exactly)
    {
        return detail::TimesConfig(exactly, exactly);
    }
 
    [[nodiscard]]
    constexpr auto at_least(const int min)
    {
        return detail::TimesConfig{
            min,
            std::numeric_limits<int>::max()
        };
    }
 
    [[nodiscard]]
    constexpr auto at_most(const int max)
    {
        return detail::TimesConfig{
            0,
            max
        };
    }
 
    [[nodiscard]]
    consteval auto once() noexcept
    {
        constexpr detail::TimesConfig config{
            1,
            1
        };
 
        return config;
    }
 
    [[nodiscard]]
    consteval auto twice() noexcept
    {
        constexpr detail::TimesConfig config{
            2,
            2
        };
 
        return config;
    }
 
}
 
#endif