ScopedSequence.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024-2026.
// 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++/Fwd.hpp"
#include "mimic++/Sequence.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Builder.hpp"
#include "mimic++/expectation/Collector.hpp"
#include "mimic++/utilities/SourceLocation.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #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 <typename Signature, auto state, typename... Args>
        [[nodiscard]]
        explicit(false) ExpectationBuilderFinalizer(
            expectation::BasicBuilder<Signature, state, Args...>&& builder,
            util::SourceLocation loc = {})
            : m_FinalizeFn{
                  [&builder, loc = std::move(loc)](Sequence& sequence) mutable {
                      return ScopedExpectation{
                          std::move(builder) and expect::in_sequence(sequence),
                          std::move(loc)};
                  }}
        {
        }
 
        [[nodiscard]]
        ScopedExpectation finalize(Sequence& sequence)
        {
            MIMICPP_ASSERT(m_FinalizeFn, "Finalize-Function was already consumed.");
 
            return std::invoke(
                std::exchange(m_FinalizeFn, nullptr),
                sequence);
        }
 
    private:
        std::function<ScopedExpectation(Sequence&)> 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) = default;

        [[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.attach(builder.finalize(*this));
 
            return *this;
        }

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

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

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

    using ScopedSequence = LazyScopedSequence;
}
 
#endif