amnesicMachineTransition.h

#pragma once
 
#include <transition/transition.h>
 
namespace TuringSim::Transition::Amnesic {
    template<typename StateType_>
    class AmnesicMachineTransition : public Transition<StateType_, std::monostate, std::monostate> {
        typedef Transition<StateType_, std::monostate, std::monostate> Transition_;
    public:
        using typename Transition_::StateType;
        using typename Transition_::StorageType;
        using typename Transition_::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>);
 
        AmnesicMachineTransition() = default;
 
        AmnesicMachineTransition(const AmnesicMachineTransition&) = default;
 
        AmnesicMachineTransition(AmnesicMachineTransition&&) = default;
 
        AmnesicMachineTransition& operator=(const AmnesicMachineTransition&) = default;
 
        AmnesicMachineTransition& operator=(AmnesicMachineTransition&&) = default;
 
        virtual ~AmnesicMachineTransition() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual std::optional<ApplyHelperType>
        match(const StateType& state, const StorageType& storage) const override final {
            return this->matchFromState(state);
        }
 
        virtual std::optional<ApplyHelperType> matchFromState(const StateType& state) const = 0;
 
        virtual StateType apply(const StateType& state, StorageType& storage, ApplyHelperType&& helper, bool& running) const override final {
            return this->applyFromState(state, running);
        }
#pragma clang diagnostic pop
 
        virtual StateType applyFromState(const StateType& state, bool& running) const = 0;
    };
 
}