manager.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ifw/core/utils/system/system.hpp>
 
#include <ifw/ccf/mptk/message.hpp>
#include <ifw/ccf/mptk/thread.hpp>
 
 
namespace ifw::ccf::mptk {

  class Manager {
  public:
 
    Manager();
 
    ~Manager();

    void Reset();

    void StartThreads();

    void PauseThreads();

    void StopThreads();

    int16_t WaitForThreadTerm(const double time_out = ifw::core::utils::base::NO_TIMEOUT);

    int16_t NbOfThreadsRunning() const;

    MessageBus& MsgBus();

    std::string ToString() const;

    template <class THREAD_TYPE>
    void CreateThread(const std::string& thread_name,
                      const double period = 0.1,
                      THREAD_TYPE** thread_obj = nullptr) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      BEGIN_CRIT_SEC(m_mgr_id) {
        m_threads[thread_name] = std::make_shared<THREAD_TYPE>(thread_name, MsgBus(), period);
        if (m_threads[thread_name].get() == nullptr) {
          throw rad::Exception(fmt::format("Could not create thread with ID: %s in MPTK instance",
            thread_name.c_str()));
        }
        MsgBus().RegisterThread(thread_name);
      } END_CRIT_SEC();
      if (thread_obj != nullptr) {
        *thread_obj = static_cast<THREAD_TYPE*>(m_threads[thread_name].get());
      } 
    }

    template <class THREAD_TYPE>
    void CreateThread(const THREAD_TYPE& factory_object,
                      const std::string& thread_name,
                      const double period = 0.1,
                      THREAD_TYPE** thread_obj = nullptr) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      BEGIN_CRIT_SEC(m_mgr_id) {
        m_threads[thread_name] = std::make_shared<THREAD_TYPE>(thread_name, MsgBus(), period);
        if (m_threads[thread_name].get() == nullptr) {
          throw rad::Exception(fmt::format("Could not create thread with ID: %s in MPTK instance",
            thread_name.c_str()));
        }
        MsgBus().RegisterThread(thread_name);
      } END_CRIT_SEC();
      if (thread_obj != nullptr) {
        *thread_obj = static_cast<THREAD_TYPE*>(m_threads[thread_name].get());
      }
    }

    template <class THREAD_TYPE>
    void GetThread(const std::string& thread_name,
                   THREAD_TYPE** thread_obj) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      ifw::core::utils::system::Mutex tmp_mutex(m_mgr_id); {
        auto thr_obj_it = m_threads.find(thread_name);
        if (thr_obj_it == m_threads.end()) {
            throw rad::Exception(fmt::format("%s: Undefined Thread Name: %s",
              m_mgr_id.c_str(), thread_name.c_str()));
          }
        *thread_obj = static_cast<THREAD_TYPE*>(thr_obj_it->second.get());
        }
 
    }

    void GetThreadNames(std::list<std::string>& thread_names) const;
 
  private:
    std::string                                    m_mgr_id;
    MessageBus                                     m_message_bus;
    std::map<std::string, std::shared_ptr<Thread>> m_threads;
  };
 
}