deterministicSimpleFiniteStateMachine.h

#pragma once
 
#include <machine/FSM/simpleFiniteStateMachine.h>
#include <transition/FSM/simpleFiniteStateMachineTransition.h>
 
namespace TuringSim::Machine::FSM {
    template <
            typename StateType,
            typename SymbolType,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class DeterministicSimpleFiniteStateMachine;
 
    template <
            typename StateType_,
            typename SymbolType_,
            AcceptingStyle acceptingStyle,
            typename... Args
    >
    class DeterministicSimpleFiniteStateMachine<StateType_, SymbolType_, acceptingStyle, std::tuple<Args...>>
            : public SimpleFiniteStateMachine<StateType_, SymbolType_, true, acceptingStyle, std::set, std::set>{
        typedef Transition::FSM::SimpleFiniteStateMachineTransition<StateType_, SymbolType_> TransitionType_;
        typedef SimpleFiniteStateMachine<StateType_, SymbolType_, true, acceptingStyle, std::set, std::set> SimpleFiniteStateMachine_;
    public:
        using typename SimpleFiniteStateMachine_::StateType;
        using typename SimpleFiniteStateMachine_::SymbolType;
        using typename SimpleFiniteStateMachine_::IsAccepting;
        using typename SimpleFiniteStateMachine_::StorageType;
        using typename SimpleFiniteStateMachine_::IsAlternating;
        using typename SimpleFiniteStateMachine_::TransitionType;
        using typename SimpleFiniteStateMachine_::ApplyHelperType;
        using typename SimpleFiniteStateMachine_::IsDeterministic;
        using typename SimpleFiniteStateMachine_::TransitionContainer;
        using typename SimpleFiniteStateMachine_::InitialStateContainer;
        using typename SimpleFiniteStateMachine_::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::true_type>);
        static_assert(std::is_same_v<TransitionContainer, std::set<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, std::set<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.");
 
        DeterministicSimpleFiniteStateMachine() = delete;
 
        DeterministicSimpleFiniteStateMachine(
                const StateType& initialState,
                const std::vector<TransitionType>& transitions,
                Args... acceptingArgs
        ) :
                SimpleFiniteStateMachine_(acceptingArgs...),
                initialState(initialState),
                transitions()
        {
            for(const TransitionType& transition: transitions) {
                this->transitions[transition.getPreState()].insert({transition.getPreLetter(), transition});
            }
        }
 
        DeterministicSimpleFiniteStateMachine(const DeterministicSimpleFiniteStateMachine&) = default;
        DeterministicSimpleFiniteStateMachine(DeterministicSimpleFiniteStateMachine&&) = default;
        DeterministicSimpleFiniteStateMachine& operator=(const DeterministicSimpleFiniteStateMachine&) = default;
        DeterministicSimpleFiniteStateMachine& operator=(DeterministicSimpleFiniteStateMachine&&) = default;
        virtual ~DeterministicSimpleFiniteStateMachine() override = default;
 
        virtual StateType getInitialState() const noexcept override final {
            return initialState;
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const noexcept override final {
            try {
                return {{transitions.at(state).at(letter.value()), std::monostate()}};
            }
            catch(std::out_of_range) {
                return {std::nullopt};
            }
            catch(std::bad_optional_access) {
                return {std::nullopt};
            }
        }
 
    protected:
        StateType initialState;
 
        std::map<StateType, std::map<SymbolType, TransitionType>> transitions;
    };
}