finiteStateMachineTransition.h

#pragma once
 
#include <memory/word.h>
#include <transition/transition.h>
 
namespace TuringSim::Transition::FSM {
    template <
            typename StateType_,
            typename SymbolType_
    >
    class FiniteStateMachineTransition :
            public Transition<StateType_, Memory::Word::Word<SymbolType_>, std::monostate> {
        typedef Memory::Word::Word<SymbolType_> StorageType_;
        typedef Transition<StateType_, StorageType_, std::monostate> Transition_;
    public:
        using typename Transition_::StateType;
        using typename Transition_::StorageType;
        using typename Transition_::ApplyHelperType;
 
        typedef SymbolType_ SymbolType;
 
        static_assert(std::is_same_v<StateType, StateType_>);
        static_assert(std::is_same_v<StorageType, Memory::Word::Word<SymbolType_>>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
 
        FiniteStateMachineTransition() = default;
 
        FiniteStateMachineTransition(const FiniteStateMachineTransition&) = default;
 
        FiniteStateMachineTransition(FiniteStateMachineTransition&&) = default;
 
        FiniteStateMachineTransition& operator=(const FiniteStateMachineTransition&) = default;
 
        FiniteStateMachineTransition& operator=(FiniteStateMachineTransition&&) = default;
 
        virtual ~FiniteStateMachineTransition() override = default;
 
        virtual std::optional<ApplyHelperType> match(const StateType& state, const StorageType& storage) const override final {
            return this->matchFromCurrentLetter(state, storage.front_opt());
        }
 
        virtual std::optional<ApplyHelperType> matchFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const = 0;
    };
}