baseLoopActions.hpp

Go to the documentation of this file.

#ifndef IFWSLM_BASE_LOOP_ACTIONS_HPP
#define IFWSLM_BASE_LOOP_ACTIONS_HPP
 
#include <ifw/slm/framework/logger.hpp>
#include <ifw/slm/framework/loopStateData.hpp>
#include <ifw/slm/framework/killableActivity.hpp>
#include <ifw/slm/framework/slConfig.hpp>
#include <ifw/slm/framework/dataContext.hpp>
 
#include <rad/configurableActionGroup.hpp>
#include <rad/application.hpp>
#include <scxml4cpp/Context.h>
#include <memory>
#include <string>
 
namespace ifw::slm {
 
class LoopCompletionHandler;
class BaseLoopExecuteActivity;

class BaseLoopActions : public rad::ConfigurableActionGroup {
public:
    BaseLoopActions(const std::string& name, 
                    rad::Application& appl,
                    rad::ConfigurableActionMgr& action_mgr, 
                    DataContext& data, 
                    int loop_index,
                    std::shared_ptr<LoopCompletionHandler> completion_handler = nullptr);
 
    virtual ~BaseLoopActions() = default;
 
    void Initialize() override;
    void Configure(const std::vector<std::string>& keys) override;

    virtual void Init(scxml4cpp::Context* c);
    virtual void Execute(scxml4cpp::Context* c);
    virtual void Complete(scxml4cpp::Context* c);
    virtual void Abort(scxml4cpp::Context* c);
    virtual void InstallTimer(scxml4cpp::Context* c);

    virtual bool DoExecute();
 
    BaseLoopActions(const BaseLoopActions&) = delete;
    BaseLoopActions& operator=(const BaseLoopActions&) = delete;

    template<typename T>
    T GetLoopParam(const std::string& name) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name);
    }
 
    template<typename T>
    T GetLoopParam(const std::string& name, const T& default_value) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name, default_value);
    }
 
protected:
    rad::Application& m_appl;
    rad::ConfigurableActionMgr& m_action_mgr;
    DataContext& m_data;
    int m_loop_index;
    std::shared_ptr<LoopCompletionHandler> m_completion_handler;
    LoopStateData m_loop_state;  // Per-loop OLDB state manager
 
    // Virtual helper methods for state transitions (can be overridden by derived classes)
    virtual void OnLoopOpen();
    virtual void OnLoopClose();
    virtual void OnLoopSuspend();
    virtual void OnCycleStart();
    virtual void OnCycleComplete(bool success);
    virtual void OnCycleError();
};

class BaseLoopExecuteActivity : public KillableThreadActivity {
public:
    BaseLoopExecuteActivity(const std::string& id,
                            rad::SMAdapter& sm,
                            DataContext& data,
                            int loop_index,
                            LoopCompletionHandler* completion_handler = nullptr);
 
    virtual ~BaseLoopExecuteActivity() = default;
 
    void Run() override;
 
    BaseLoopExecuteActivity(const BaseLoopExecuteActivity&) = delete;
    BaseLoopExecuteActivity& operator=(const BaseLoopExecuteActivity&) = delete;

    template<typename T>
    T GetLoopParam(const std::string& name) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name);
    }

    template<typename T>
    T GetLoopParam(const std::string& name, const T& default_value) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name, default_value);
    }

    template<typename T>
    bool ReadLoopOldb(const std::string& name, T& out) const {
        try {
            m_data.GetOldbInterface().GetValue<T>(GetLoopOldbKey(m_loop_index, name), out);
            return true;
        } catch (...) {
            return false;
        }
    }
 
protected:
    virtual bool DoExecute() = 0;
 
    rad::SMAdapter& m_sm;
    DataContext& m_data;
    int m_loop_index;
    LoopStateData m_loop_state;  // Per-loop OLDB state manager
    LoopCompletionHandler* m_completion_handler;
 
protected:
    log4cplus::Logger m_logger = log4cplus::Logger::getInstance(LOGGER_NAME + ".BaseLoopExecuteActivity");
};

class BaseLoopSuspendedActions : public rad::ConfigurableActionGroup {
public:
    BaseLoopSuspendedActions(const std::string& name, 
                             rad::Application& appl,
                             rad::ConfigurableActionMgr& action_mgr, 
                             DataContext& data, 
                             int loop_index,
                             std::shared_ptr<LoopCompletionHandler> completion_handler = nullptr);
 
    virtual ~BaseLoopSuspendedActions() = default;
 
    void Initialize() override;
    void Configure(const std::vector<std::string>& keys) override;
 
    virtual void Execute(scxml4cpp::Context* c);
    virtual void Complete(scxml4cpp::Context* c);
    virtual void Abort(scxml4cpp::Context* c);
    virtual void InstallTimer(scxml4cpp::Context* c);
 
    BaseLoopSuspendedActions(const BaseLoopSuspendedActions&) = delete;
    BaseLoopSuspendedActions& operator=(const BaseLoopSuspendedActions&) = delete;
 
protected:
    rad::Application& m_appl;
    rad::ConfigurableActionMgr& m_action_mgr;
    DataContext& m_data;
    int m_loop_index;
    std::shared_ptr<LoopCompletionHandler> m_completion_handler;
    LoopStateData m_loop_state;  // Per-loop OLDB state manager
 
    // Virtual helper methods for state transitions (can be overridden by derived classes)
    virtual void OnLoopOpen();
    virtual void OnLoopClose();
    virtual void OnLoopSuspend();
    virtual void OnCycleStart();
    virtual void OnCycleComplete(bool success);
    virtual void OnCycleError();
};

template<int LOOP_INDEX>
class ActionsLoopSuspended : public BaseLoopSuspendedActions {
public:
    using base_type = BaseLoopSuspendedActions;
 
    ActionsLoopSuspended(const std::string& name,
                        rad::Application& appl,
                        rad::ConfigurableActionMgr& action_mgr,
                        DataContext& data,
                        int loop_index,
                        std::shared_ptr<LoopCompletionHandler> completion_handler)
        : base_type(name, appl, action_mgr, data, loop_index, completion_handler) {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(),
            "Creating ActionsLoop" << LOOP_INDEX << "Suspended");
    }
 
    ~ActionsLoopSuspended() override {
        RAD_TRACE(GetLogger());
    }
 
    void Execute(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(),
            "Loop " << m_loop_index << " Suspended - Execute called");
        base_type::Execute(c);  // mark the loop SUSPENDED
    }
 
    void Complete(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(),
            "Loop " << m_loop_index << " Suspended - Complete called");
        base_type::Complete(c);
    }
 
    void Abort(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(),
            "Loop " << m_loop_index << " Suspended - Aborting");
        base_type::Abort(c);
    }
 
    ActionsLoopSuspended(const ActionsLoopSuspended&) = delete;
    ActionsLoopSuspended& operator=(const ActionsLoopSuspended&) = delete;
};

class BaseLoopCloseActions : public rad::ConfigurableActionGroup {
public:
    BaseLoopCloseActions(const std::string& name, 
                         rad::Application& appl,
                         rad::ConfigurableActionMgr& action_mgr, 
                         DataContext& data, 
                         int loop_index,
                         std::shared_ptr<LoopCompletionHandler> completion_handler = nullptr);
 
    virtual ~BaseLoopCloseActions() = default;
 
    void Initialize() override;
    void Configure(const std::vector<std::string>& keys) override;
 
    virtual void Execute(scxml4cpp::Context* c);
    virtual void Complete(scxml4cpp::Context* c);
    virtual void Abort(scxml4cpp::Context* c);
    virtual void InstallTimer(scxml4cpp::Context* c);
    virtual void CycleError(scxml4cpp::Context* c);
 
    BaseLoopCloseActions(const BaseLoopCloseActions&) = delete;
    BaseLoopCloseActions& operator=(const BaseLoopCloseActions&) = delete;

    template<typename T>
    T GetLoopParam(const std::string& name) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name);
    }
 
    template<typename T>
    T GetLoopParam(const std::string& name, const T& default_value) const {
        return GetLoopParamFromConfig<T>(m_data.GetConfig(), m_loop_index, name, default_value);
    }
 
protected:
    rad::Application& m_appl;
    rad::ConfigurableActionMgr& m_action_mgr;
    DataContext& m_data;
    int m_loop_index;
    std::shared_ptr<LoopCompletionHandler> m_completion_handler;
    LoopStateData m_loop_state;  // Per-loop OLDB state manager
 
    // Virtual helper methods for state transitions (can be overridden by derived classes)
    virtual void OnLoopOpen();
    virtual void OnLoopClose();
    virtual void OnLoopSuspend();
    virtual void OnCycleStart();
    virtual void OnCycleComplete(bool success);
    virtual void OnCycleError();
};
 
// Type aliases for the 9 suspended loop action classes
using ActionsLoop1S = ActionsLoopSuspended<1>;
using ActionsLoop2S = ActionsLoopSuspended<2>;
using ActionsLoop3S = ActionsLoopSuspended<3>;
using ActionsLoop4S = ActionsLoopSuspended<4>;
using ActionsLoop5S = ActionsLoopSuspended<5>;
using ActionsLoop6S = ActionsLoopSuspended<6>;
using ActionsLoop7S = ActionsLoopSuspended<7>;
using ActionsLoop8S = ActionsLoopSuspended<8>;
using ActionsLoop9S = ActionsLoopSuspended<9>;
 
} // namespace ifw::slm
 
#endif // IFWSLM_BASE_LOOP_ACTIONS_HPP