pubThread.hpp

Go to the documentation of this file.

 
#ifndef CCF_CONTROL_PUB_THREAD_HPP_H_
#define CCF_CONTROL_PUB_THREAD_HPP_H_
 
#include "ccf/common/base.hpp"
#include "ccf/common/utilities.hpp"
#include "ccf/common/frameQueue.hpp"
#include "ccf/common/pubBase.hpp"
 
namespace ccf::control {
 
  class PubThread: public ccf::mptk::Thread, public ccf::Base {
  public:
 
    static void SetStatusAll(const ccf::PubStatus status);
 
    PubThread(const std::string& thread_name,
              ccf::mptk::MessageBus& message_bus,
              const double period = 0.1);
 
    virtual ~PubThread();
 
    void Initialise();
 
    virtual void UserLogic();
 
    void SetProcThrOutputQ(std::shared_ptr<ccf::common::FrameQueue>& queue);
 
    ccf::common::FrameQueue& GetProcThrOutputQ();
 
    void SetStatus(const ccf::PubStatus status);
 
    ccf::PubStatus GetStatus() const;
 
    void AddPublisher(ccf::common::PubBase& pub_obj);
 
    uint8_t NbOfPublishers() const;
 
    const ccf::common::PubBase& GetPublisher(const uint16_t nb) const;
 
    const std::list<ccf::common::PubBase*>& GetPublishers() const;
 
    void SetParentProcThreadName(const std::string& parent_proc_thread_name);
 
    const std::string& GetParentProcThreadName() const;
 
    ccf::common::FrameStatistics& GetFrameStat();
 
  protected:
 
  private:
    bool _CheckMessageBus(bool& new_data_available,
                          bool& new_setup);
    void _GetFrameHandleRef();
    void _InvokePublishers();
    void _ReleaseFrameHandle();
    void _HandleNewSetup(ccf::Status status, 
                         std::string& diagnostics);
 
    std::string  m_parent_proc_thr_name;
 
    ccf::mptk::Message      m_cur_msg;   // Current thread message being handled.
 
    // Current data frame being handled. Should not be shared_ptr.
    ccf::common::DataFrame* m_cur_frame; 
 
    // Used to avoid updating OLDB/PubSub unnecessary.
    ccf::PubStatus m_pub_thread_status;
 
    std::list<ccf::common::PubBase*> m_publishers;
 
    // Map to find Data Publisher objects easily by means of the Thread ID.
    std::map<std::string, ccf::common::PubBase*> m_publisher_map;
 
    // Note: The queues are allocated and deleted by the ccf::control::application class.
    std::shared_ptr<ccf::common::FrameQueue> m_proc_thr_output_q;
 
    ccf::common::FrameStatistics m_frame_stat;
 
    bool                         m_pipeline_enabled;
  };
 
}
 
#endif // CCF_CONTROL_PUB_THREAD_HPP_H_