simpleAmnesicMachine.h

#pragma once
 
#include <machine/amnesic/stateAcceptingAmnesicMachine.h>
#include <transition/amnesic/simpleAmnesicMachineTransition.h>
 
namespace TuringSim::Machine::Amnesic {
    template<
            typename StateType,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template<typename...> class TransitionContainer = std::vector,
            template<typename...> class InitialStateContainer = std::set
    >
    using StateAcceptingSimpleAmnesicMachine = StateAcceptingAmnesicMachine<
            Transition::Amnesic::SimpleAmnesicMachineTransition<StateType>,
            deterministic,
            acceptingStyle,
            TransitionContainer,
            InitialStateContainer>;
 
    template<
            typename StateType,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template<typename...> class TransitionContainer = std::vector,
            template<typename...> class InitialStateContainer = std::set,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class SimpleAmnesicMachine;
 
    template<
            typename StateType_,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template<typename...> class TransitionContainer_,
            template<typename...> class InitialStateContainer_,
            typename... Args
    >
    class SimpleAmnesicMachine<StateType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_, std::tuple<Args...>>
            : public StateAcceptingSimpleAmnesicMachine<StateType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> {
        typedef Transition::Amnesic::SimpleAmnesicMachineTransition<StateType_> TransitionType_;
        typedef StateAcceptingSimpleAmnesicMachine<StateType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> SimpleAmnesicMachine_accept_impl_;
    public:
        using typename SimpleAmnesicMachine_accept_impl_::StateType;
        using typename SimpleAmnesicMachine_accept_impl_::IsAccepting;
        using typename SimpleAmnesicMachine_accept_impl_::StorageType;
        using typename SimpleAmnesicMachine_accept_impl_::IsAlternating;
        using typename SimpleAmnesicMachine_accept_impl_::TransitionType;
        using typename SimpleAmnesicMachine_accept_impl_::ApplyHelperType;
        using typename SimpleAmnesicMachine_accept_impl_::IsDeterministic;
        using typename SimpleAmnesicMachine_accept_impl_::TransitionContainer;
        using typename SimpleAmnesicMachine_accept_impl_::InitialStateContainer;
        using typename SimpleAmnesicMachine_accept_impl_::OptionalHelpedTransition;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<StorageType, typename TransitionType::StorageType>);
        static_assert(std::is_same_v<TransitionType, TransitionType_>);
        static_assert(std::is_same_v<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
        static_assert(std::is_same_v<IsDeterministic, std::integral_constant<bool, deterministic>>);
        static_assert(std::is_same_v<TransitionContainer, TransitionContainer_<std::pair<const TransitionType& , ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, InitialStateContainer_<StateType>>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType& , ApplyHelperType>>>);
 
        static_assert(std::is_same_v<StorageType, std::monostate>,
                      "StorageType should be a word.");
        static_assert(std::is_same_v<TransitionType_, TransitionType>,
                      "TransitionType must be SimpleAmnesicMachineTransition.");
        static_assert(std::is_same_v<std::tuple<Args...>, typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs>,
                      "The only valid value for AcceptingConstructorArgs is the default parameter.");
 
        SimpleAmnesicMachine() = delete;
 
        SimpleAmnesicMachine(const std::set<StateType>& finalStates, Args... args) :
                SimpleAmnesicMachine_accept_impl_(args...),
                finalStates(finalStates) {}
 
        SimpleAmnesicMachine(const SimpleAmnesicMachine&) = default;
 
        SimpleAmnesicMachine(SimpleAmnesicMachine&&) = default;
 
        SimpleAmnesicMachine& operator=(const SimpleAmnesicMachine&) = default;
 
        SimpleAmnesicMachine& operator=(SimpleAmnesicMachine&&) = default;
 
        virtual ~SimpleAmnesicMachine() override = default;
 
        virtual bool isHaltingState(const StateType& state) const noexcept override final {
            return finalStates.count(state) > 0;
        }
 
    protected:
        std::set<StateType> finalStates;
    };
}