finite_state_machine_8h_source.html

#pragma once


#include <machine/machine.h>

#include <transition/FSM/finiteStateMachineTransition.h>


namespace TuringSim::Machine::FSM {

    template <

            typename TransitionType_,

            bool deterministic,

            AcceptingStyle acceptingStyle,

            template <typename...> class TransitionContainer_ = std::vector,

            template <typename...> class InitialStateContainer_ = std::vector

    >

    class FiniteStateMachine;


    template <

            typename TransitionType_,

            AcceptingStyle acceptingStyle,

            template <typename...> class TransitionContainer_,

            template <typename...> class InitialStateContainer_

    >

    class FiniteStateMachine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> :

            public Machine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_>{

        typedef Machine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> Machine_;

    public:

        using typename Machine_::StateType;

        using typename Machine_::IsAccepting;

        using typename Machine_::StorageType;

        using typename Machine_::IsAlternating;

        using typename Machine_::TransitionType;

        using typename Machine_::ApplyHelperType;

        using typename Machine_::IsDeterministic;

        using typename Machine_::TransitionContainer;

        using typename Machine_::InitialStateContainer;

        using typename Machine_::OptionalHelpedTransition;


        typedef typename StorageType::SymbolType SymbolType;


        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::true_type>);

        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_base_of_v<Transition::FSM::FiniteStateMachineTransition<StateType, SymbolType>, TransitionType>,

                      "TransitionType must be a derived class of FiniteStateMachineTransition");


        FiniteStateMachine() = default;

        FiniteStateMachine(const FiniteStateMachine&) = default;

        FiniteStateMachine(FiniteStateMachine&&) = default;

        FiniteStateMachine& operator=(const FiniteStateMachine&) = default;

        FiniteStateMachine& operator=(FiniteStateMachine&&) = default;

        virtual ~FiniteStateMachine() override = default;


        virtual OptionalHelpedTransition getMatchingTransition(const StateType& state, const StorageType& storage) const noexcept override final {

            return this->getMatchingTransitionFromCurrentLetter(state, storage.front_opt());

        }


        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const noexcept = 0;

    };


    template <

            typename TransitionType_,

            AcceptingStyle acceptingStyle,

            template <typename...> class TransitionContainer_,

            template <typename...> class InitialStateContainer_

    >

    class FiniteStateMachine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> :

            public Machine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> {

        typedef Machine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> Machine_;

    public:

        using typename Machine_::StateType;

        using typename Machine_::IsAccepting;

        using typename Machine_::StorageType;

        using typename Machine_::IsAlternating;

        using typename Machine_::TransitionType;

        using typename Machine_::ApplyHelperType;

        using typename Machine_::IsDeterministic;

        using typename Machine_::TransitionContainer;

        using typename Machine_::InitialStateContainer;

        using typename Machine_::OptionalHelpedTransition;


        typedef typename StorageType::SymbolType SymbolType;


        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::false_type>);

        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_base_of_v<Transition::FSM::FiniteStateMachineTransition<StateType, SymbolType>, TransitionType>,

                      "TransitionType must be a derived class of FiniteStateMachineTransition");


        FiniteStateMachine() = default;

        FiniteStateMachine(const FiniteStateMachine&) = default;

        FiniteStateMachine(FiniteStateMachine&&) = default;

        FiniteStateMachine& operator=(const FiniteStateMachine&) = default;

        FiniteStateMachine& operator=(FiniteStateMachine&&) = default;

        virtual ~FiniteStateMachine() override = default;


        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& storage) const noexcept override final {

            return this->getMatchingTransitionsFromCurrentLetter(state, storage.front_opt());

        }


        virtual TransitionContainer getMatchingTransitionsFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const noexcept = 0;

    };

}