simpleFiniteStateMachine.h

#pragma once
 
#include <machine/FSM/stateAcceptingFiniteStateMachine.h>
#include <transition/FSM/simpleFiniteStateMachineTransition.h>
 
namespace TuringSim::Machine::FSM {
    template <
            typename StateType,
            typename SymbolType,
            bool deterministic,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            template <typename...> class TransitionContainer = std::vector,
            template <typename...> class InitialStateContainer = std::vector,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class SimpleFiniteStateMachine;
 
    template <
            typename StateType_,
            typename SymbolType_,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_,
            typename... Args
    >
    class SimpleFiniteStateMachine<StateType_, SymbolType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_, std::tuple<Args...>>
            : public StateAcceptingFiniteStateMachine<Transition::FSM::SimpleFiniteStateMachineTransition<StateType_, SymbolType_>, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> {
        typedef Transition::FSM::SimpleFiniteStateMachineTransition<StateType_, SymbolType_> TransitionType_;
        typedef StateAcceptingFiniteStateMachine<TransitionType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> StateAcceptingFiniteStateMachine_;
    public:
        using typename StateAcceptingFiniteStateMachine_::StateType;
        using typename StateAcceptingFiniteStateMachine_::SymbolType;
        using typename StateAcceptingFiniteStateMachine_::IsAccepting;
        using typename StateAcceptingFiniteStateMachine_::StorageType;
        using typename StateAcceptingFiniteStateMachine_::IsAlternating;
        using typename StateAcceptingFiniteStateMachine_::TransitionType;
        using typename StateAcceptingFiniteStateMachine_::ApplyHelperType;
        using typename StateAcceptingFiniteStateMachine_::IsDeterministic;
        using typename StateAcceptingFiniteStateMachine_::TransitionContainer;
        using typename StateAcceptingFiniteStateMachine_::InitialStateContainer;
        using typename StateAcceptingFiniteStateMachine_::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, Memory::Word::Word<SymbolType>>,
                      "StorageType should be a word.");
        static_assert(std::is_same_v<TransitionType_, TransitionType>,
                      "TransitionType must be SimpleFiniteStateMachineTransition");
        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.");
 
        SimpleFiniteStateMachine(Args... args) :
                StateAcceptingFiniteStateMachine_(args...)
        {}
 
        SimpleFiniteStateMachine(const SimpleFiniteStateMachine&) = default;
        SimpleFiniteStateMachine(SimpleFiniteStateMachine&&) = default;
        SimpleFiniteStateMachine& operator=(const SimpleFiniteStateMachine&) = default;
        SimpleFiniteStateMachine& operator=(SimpleFiniteStateMachine&&) = default;
        virtual ~SimpleFiniteStateMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return storage.isEndOfWord();
        }
#pragma clang diagnostic pop
    };
}