transition.h

#pragma once
 
#include <utils/messageException.h>
#include <utils/printer.h>
 
namespace TuringSim::Transition {
    template <typename TransitionType>
    class [[maybe_unused]] ConfigurationDoesNotMatchException : public Utils::MessageException {
    public:
        ConfigurationDoesNotMatchException() = delete;
 
        ConfigurationDoesNotMatchException(
                std::string message,
                typename TransitionType::StateType_ preState,
                typename TransitionType::StorageType_ storage,
                typename TransitionType::ApplyHelperType& applyHelper
        ) :
                MessageException(message),
                preState(preState),
                storage(storage),
                applyHelper(applyHelper)
        {}
 
    protected:
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::stringstream ss;
            ss << this->msg << std::endl;
            ss << "  transition: " << transition << std::endl;
            ss << "  preState: " << preState << std::endl;
            ss << "  storage: " << storage << std::endl;
            ss << "  applyHelper: " << applyHelper << std::endl;
        }
 
        TransitionType transition;  
        typename TransitionType::StateType_ preState;  
        typename TransitionType::StorageType_ storage;  
        typename TransitionType::ApplyHelperType& applyHelper;  
    };
 
    template <
            typename StateType_,
            typename StorageType_,
            typename ApplyHelperType_
    >
    class Transition {
    public:
        typedef StateType_ StateType;
 
        typedef StorageType_ StorageType;
 
        typedef ApplyHelperType_ ApplyHelperType;
 
        Transition() = default;
 
        Transition(const Transition&) = default;
 
        Transition(Transition&&) = default;
 
        Transition& operator=(const Transition&) = default;
 
        Transition& operator=(Transition&&) = default;
 
        virtual ~Transition() = default;
 
        virtual std::optional<ApplyHelperType> match(const StateType& state, const StorageType& storage) const = 0;
 
        virtual StateType apply(const StateType& state, StorageType& storage, ApplyHelperType&& helper, bool& running) const = 0;
    };
 
}