actionMgr.hpp

Go to the documentation of this file.

#ifndef IFWSLM_ACTION_MGR_HPP
#define IFWSLM_ACTION_MGR_HPP
 
#include <rad/configurableActionMgr.hpp>
#include <rad/application.hpp>
#include <functional>
#include <map>
#include <memory>
 
namespace ifw::slm {
 
class DataContext;
class BaseLoopActions;
class BaseLoopSuspendedActions;
class BaseLoopCloseActions;
class LoopCompletionHandler;
class BaseLoopExecuteActivity;
 
// Forward declarations for test classes
class TestActionMgr;
class TestSuspendedActions;
class TestLoopCloseActions;
 
// Friend declarations for test classes to access private helper methods

class ActionMgr : public rad::ConfigurableActionMgr {
 public:
    using LoopActionFactory = std::function<BaseLoopActions*(
        const std::string&, rad::Application&, rad::ConfigurableActionMgr&, DataContext&, int,
        std::shared_ptr<LoopCompletionHandler>)>;
    using LoopSuspendedActionFactory = std::function<BaseLoopSuspendedActions*(
        const std::string&, rad::Application&, rad::ConfigurableActionMgr&, DataContext&, int,
        std::shared_ptr<LoopCompletionHandler>)>;
    using LoopCloseActionFactory = std::function<BaseLoopCloseActions*(
        const std::string&, rad::Application&, rad::ConfigurableActionMgr&, DataContext&, int,
        std::shared_ptr<LoopCompletionHandler>)>;

    using LoopExecuteActivityFactory = std::function<BaseLoopExecuteActivity*(
        const std::string&, rad::SMAdapter&, DataContext&, int, LoopCompletionHandler*)>;

    ActionMgr(DataContext& the_data);

    virtual ~ActionMgr();

    void RegisterLoopActionFactory(int loop_index, LoopActionFactory factory);

    void RegisterLoopSuspendedActionFactory(int loop_index, LoopSuspendedActionFactory factory);

    void RegisterLoopCloseActionFactory(int loop_index, LoopCloseActionFactory factory);

    void RegisterLoopExecuteActivityFactory(int loop_index, LoopExecuteActivityFactory factory);

    void CreateActions(rad::Application& appl) override;

    void CreateActivities(rad::Application& appl) override;
 
    ActionMgr(const ActionMgr&) = delete;           
    ActionMgr& operator=(const ActionMgr&) = delete;  
 
 private:
    DataContext& m_data;
    std::map<int, LoopActionFactory> m_loop_action_factories;
    std::map<int, LoopSuspendedActionFactory> m_loop_suspended_factories;
    std::map<int, LoopCloseActionFactory> m_loop_close_factories;
    std::map<int, LoopExecuteActivityFactory> m_loop_activity_factories;
    std::shared_ptr<LoopCompletionHandler> m_completion_handler;

    BaseLoopActions* CreateLoopAction(int loop_index, const std::string& name,
                                      rad::Application& appl);
 
    // Note: CreateLoopSuspendedAction is public for testing purposes
 public:
    BaseLoopSuspendedActions* CreateLoopSuspendedAction(int loop_index, const std::string& name,
                                                         rad::Application& appl);
 
    // Note: CreateLoopCloseAction is public for testing purposes
    BaseLoopCloseActions* CreateLoopCloseAction(int loop_index, const std::string& name,
                                                 rad::Application& appl);
 
    // Note: CreateLoopExecuteActivity is public for testing purposes
 public:
    BaseLoopExecuteActivity* CreateLoopExecuteActivity(int loop_index, const std::string& name,
                                                        rad::SMAdapter& sm);
};
 
}  // namespace ifw::slm
 
#endif  // IFWSLM_ACTION_MGR_HPP