ScopedSequence.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// 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_SCOPED_SEQUENCE_HPP
#define MIMICPP_SCOPED_SEQUENCE_HPP
 
#pragma once
 
#include "mimic++/Expectation.hpp"
#include "mimic++/ExpectationBuilder.hpp"
#include "mimic++/Sequence.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/utilities/SourceLocation.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <deque>
    #include <functional>
    #include <utility>
#endif
 
namespace mimicpp::sequence::detail
{
    template <typename Sequence>
    class ExpectationBuilderFinalizer
    {
    public:
        ExpectationBuilderFinalizer(ExpectationBuilderFinalizer const&) = delete;
        ExpectationBuilderFinalizer& operator=(ExpectationBuilderFinalizer const&) = delete;
        ExpectationBuilderFinalizer(ExpectationBuilderFinalizer&&) = delete;
        ExpectationBuilderFinalizer& operator=(ExpectationBuilderFinalizer&&) = delete;
 
        ~ExpectationBuilderFinalizer() = default;
 
        template <bool timesConfigured, typename... Args>
        [[nodiscard]]
        explicit(false) constexpr ExpectationBuilderFinalizer(
            BasicExpectationBuilder<timesConfigured, Args...>&& builder,
            util::SourceLocation loc = {})
            : m_Builder{&builder},
              m_SourceLocation{std::move(loc)},
              m_FinalizeFn{
                  +[](void* storage, util::SourceLocation finalLoc, Sequence& sequence) {
                      auto* builderPtr = static_cast<BasicExpectationBuilder<timesConfigured, Args...>*>(storage);
                      return ScopedExpectation{
                          std::move(*builderPtr) and expect::in_sequence(sequence),
                          std::move(finalLoc)};
                  }}
        {
        }
 
        [[nodiscard]]
        ScopedExpectation finalize(Sequence& sequence)
        {
            MIMICPP_ASSERT(m_Builder, "Builder is nullptr.");
            MIMICPP_ASSERT(m_FinalizeFn, "FinalizeFn is nullptr.");
 
            return std::invoke(
                std::exchange(m_FinalizeFn, nullptr),
                std::exchange(m_Builder, nullptr),
                std::move(m_SourceLocation),
                sequence);
        }
 
    private:
        void* m_Builder;
        util::SourceLocation m_SourceLocation;
 
        using FinalizeFn = ScopedExpectation (*)(void*, util::SourceLocation, Sequence&);
        FinalizeFn m_FinalizeFn;
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    template <auto Strategy>
    class BasicScopedSequence
        : public sequence::detail::BasicSequenceInterface<sequence::Id, Strategy>
    {
    public:
        [[nodiscard]]
        BasicScopedSequence(BasicScopedSequence const&) = delete;

        BasicScopedSequence& operator=(BasicScopedSequence const&) = delete;

        ~BasicScopedSequence() noexcept(false)
        {
            auto expectations = std::exchange(m_Expectations, {});
            while (!expectations.empty())
            {
                // Prevent the `pop_front() noexcept` from raising an exception and thus terminating.
                auto const expectation = std::move(expectations.front());
                expectations.pop_front();
            }
        }

        [[nodiscard]]
        explicit BasicScopedSequence([[maybe_unused]] auto&&... canary, util::SourceLocation loc = {})
            : sequence::detail::BasicSequenceInterface<sequence::Id, Strategy>{std::move(loc)}
        {
            static_assert(0u == sizeof...(canary), "ScopedSequence does not accept constructor arguments.");
        }

        [[nodiscard]]
        BasicScopedSequence(BasicScopedSequence&&) = default;

        BasicScopedSequence& operator=(BasicScopedSequence&&) = default;

        BasicScopedSequence& operator+=(sequence::detail::ExpectationBuilderFinalizer<BasicScopedSequence>&& builder)
        {
            m_Expectations.emplace_back(builder.finalize(*this));
 
            return *this;
        }

        [[nodiscard]]
        std::deque<ScopedExpectation> const& expectations() const noexcept
        {
            return m_Expectations;
        }
 
    private:
        std::deque<ScopedExpectation> m_Expectations{};
    };

    using GreedyScopedSequence = BasicScopedSequence<sequence::detail::GreedyStrategy{}>;

    using LazyScopedSequence = BasicScopedSequence<sequence::detail::LazyStrategy{}>;

    using ScopedSequence = LazyScopedSequence;
}
 
#endif