maybeEpsilonFiniteStateMachineTransition.h

#pragma once
 
#include <transition/FSM/finiteStateMachineTransition.h>
 
namespace TuringSim::Transition::FSM {
    template <
            typename StateType_,
            typename SymbolType_
    >
    class MaybeEpsilonFiniteStateMachineTransition :
            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>);
 
        MaybeEpsilonFiniteStateMachineTransition() = delete;
 
        MaybeEpsilonFiniteStateMachineTransition(
                const StateType& preState,
                const std::optional<SymbolType>& preLetter,
                const StateType& postState) :
                preState(preState),
                preLetter(preLetter),
                postState(postState)
        {}
 
        MaybeEpsilonFiniteStateMachineTransition(
                const StateType& preState,
                const StateType& postState) :
                preState(preState),
                preLetter(std::nullopt),
                postState(postState)
        {}
 
        MaybeEpsilonFiniteStateMachineTransition(const MaybeEpsilonFiniteStateMachineTransition&) = default;
 
        MaybeEpsilonFiniteStateMachineTransition(MaybeEpsilonFiniteStateMachineTransition&&) = default;
 
        MaybeEpsilonFiniteStateMachineTransition& operator=(const MaybeEpsilonFiniteStateMachineTransition&) = default;
 
        MaybeEpsilonFiniteStateMachineTransition& operator=(MaybeEpsilonFiniteStateMachineTransition&&) = default;
 
        virtual ~MaybeEpsilonFiniteStateMachineTransition() override = default;
 
        virtual std::optional<ApplyHelperType> matchFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& letter) const override final {
            if(state == preState && (!preLetter || *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 {
            if(preLetter) {
                storage.read();
            }
            return postState;
        }
#pragma clang diagnostic pop
 
        const StateType& getPreState() const noexcept {
            return preState;
        }
 
        const std::optional<SymbolType>& getPreLetter() const noexcept {
            return preLetter;
        }
 
        int compare(const MaybeEpsilonFiniteStateMachineTransition& 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 MaybeEpsilonFiniteStateMachineTransition& other) const {
            return compare(other) < 0;
        }
 
        bool operator==(const MaybeEpsilonFiniteStateMachineTransition& 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 MaybeEpsilonFiniteStateMachineTransition& transition) {
            if(transition.preLetter) {
                return os << "(" << transition.preState << ", " << *transition.preLetter << ") -> "
                          << transition.postState;
            }
            return os << transition.preState << " -> " << transition.postState;
        }
 
 
    private:
        StateType preState;
        std::optional<SymbolType> preLetter;
        StateType postState;
    };
}