simpleFiniteStateMachineTransition.h

#pragma once
 
#include <utils/compare.h>
#include <transition/FSM/finiteStateMachineTransition.h>
 
namespace TuringSim::Transition::FSM {
    template <
            typename StateType_,
            typename SymbolType_
    >
    class SimpleFiniteStateMachineTransition :
            public FiniteStateMachineTransition<StateType_, SymbolType_> {
        typedef FiniteStateMachineTransition<StateType_, SymbolType_> FiniteStateMachineTransition_;
    public:
        using typename FiniteStateMachineTransition_::StateType;
        using typename FiniteStateMachineTransition_::SymbolType;
        using typename FiniteStateMachineTransition_::StorageType;
        using typename FiniteStateMachineTransition_::ApplyHelperType;
 
        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>);
 
        SimpleFiniteStateMachineTransition() = delete;
 
        SimpleFiniteStateMachineTransition(
                StateType preState,
                SymbolType preLetter,
                StateType postState) :
                preState(preState),
                preLetter(preLetter),
                postState(postState)
        {}
 
        SimpleFiniteStateMachineTransition(const SimpleFiniteStateMachineTransition&) = default;
 
        SimpleFiniteStateMachineTransition(SimpleFiniteStateMachineTransition&&) = default;
 
        SimpleFiniteStateMachineTransition& operator=(const SimpleFiniteStateMachineTransition&) = default;
 
        SimpleFiniteStateMachineTransition& operator=(SimpleFiniteStateMachineTransition&&) = default;
 
        virtual ~SimpleFiniteStateMachineTransition() override = default;
 
        virtual std::optional<ApplyHelperType> matchFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const override final {
            if(state == preState && letter && *letter == preLetter) {
                return {std::monostate{}};
            }
            return std::nullopt;
        }
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual StateType apply(const StateType& state, StorageType& storage, ApplyHelperType&& helper, bool& running) const override final {
            storage.read();
            return postState;
        }
#pragma clang diagnostic pop
 
        const StateType& getPreState() const noexcept {
            return preState;
        }
 
        const SymbolType& getPreLetter() const noexcept {
            return preLetter;
        }
 
        int compare(const SimpleFiniteStateMachineTransition& other) const {
            if(preState < other.preState) {
                return -1;
            }
            if(preState > other.preState) {
                return 1;
            }
            if(preLetter < other.preLetter) {
                return -1;
            }
            if(preLetter > other.preLetter) {
                return 1;
            }
            if(postState < other.postState) {
                return -1;
            }
            if(postState > other.postState) {
                return 1;
            }
            return 0;
        }
 
        bool operator<(const SimpleFiniteStateMachineTransition& other) const {
            return compare(other) < 0;
        }
 
        bool operator==(const SimpleFiniteStateMachineTransition& other) const {
            return compare(other) == 0;
        }
 
        template<typename CharT, typename Traits = std::char_traits<CharT>>
        friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const SimpleFiniteStateMachineTransition& transition) {
            return os << "(" << transition.preState << ", " << transition.preLetter << ") -> " << transition.postState;
        }
 
    private:
        StateType preState;
        SymbolType preLetter;
        StateType postState;
    };
}