simpleAmnesicMachineTransition.h

#pragma once
 
#include <transition/amnesic/amnesicMachineTransition.h>
 
namespace TuringSim::Transition::Amnesic {
 
    template<typename StateType_>
    class SimpleAmnesicMachineTransition
            : public AmnesicMachineTransition<StateType_> {
        typedef AmnesicMachineTransition<StateType_> AmnesicMachineTransition_;
    public:
        using typename AmnesicMachineTransition_::StateType;
        using typename AmnesicMachineTransition_::StorageType;
        using typename AmnesicMachineTransition_::ApplyHelperType;
 
        static_assert(std::is_same_v<StateType, StateType_>);
        static_assert(std::is_same_v<StorageType, std::monostate>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
 
        SimpleAmnesicMachineTransition() = delete;
        SimpleAmnesicMachineTransition(const StateType& preState, const StateType& postState) :
                preState(preState), postState(postState)
        {}
        SimpleAmnesicMachineTransition(const StateType& preState, const StateType& postState, bool terminating) :
                preState(preState), postState(postState), terminating(terminating)
        {}
 
        SimpleAmnesicMachineTransition(const SimpleAmnesicMachineTransition&) = default;
 
        SimpleAmnesicMachineTransition(SimpleAmnesicMachineTransition&&) = default;
 
        SimpleAmnesicMachineTransition& operator=(const SimpleAmnesicMachineTransition&) = default;
 
        SimpleAmnesicMachineTransition& operator=(SimpleAmnesicMachineTransition&&) = default;
 
        virtual ~SimpleAmnesicMachineTransition() override = default;
 
        virtual std::optional<ApplyHelperType> matchFromState(const StateType& state) const override final {
            if(state == preState) {
                return {std::monostate{}};
            }
            return {};
        }
 
        virtual StateType applyFromState(const StateType&, bool& running) const override final {
            running = !terminating;
            return postState;
        }
 
        const StateType& getPreState() const noexcept {
            return preState;
        }
 
        const StateType& getPostState() const noexcept {
            return postState;
        }
 
        bool isTerminating() const noexcept {
            return terminating;
        }
 
        bool operator<(const SimpleAmnesicMachineTransition& other) const {
            if(preState < other.preState) {
                return true;
            }
            if(preState > other.preState) {
                return false;
            }
            if(postState < other.postState) {
                return true;
            }
            if(postState > other.postState) {
                return false;
            }
            if(terminating == other.terminating) {
                return false;
            }
            return other.terminating;
        }
 
    private:
        StateType preState;
        StateType postState;
        bool terminating = false;
    };
}