DAQModule.hpp

Go to the documentation of this file.

 
#ifndef APPFWK_INCLUDE_APPFWK_DAQMODULE_HPP_
#define APPFWK_INCLUDE_APPFWK_DAQMODULE_HPP_
 
#include "appfwk/ConfigurationManager.hpp"
 
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
#include "opmonlib/MonitorableObject.hpp"
#include "utilities/NamedObject.hpp"
 
#include "cetlib/BasicPluginFactory.h"
#include "cetlib/compiler_macros.h"
#include "ers/Issue.hpp"
#include "nlohmann/json.hpp"
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#ifndef EXTERN_C_FUNC_DECLARE_START
// NOLINTNEXTLINE(build/define_used)
#define EXTERN_C_FUNC_DECLARE_START                                                                                    \
  extern "C"                                                                                                           \
  {
#endif

// NOLINTNEXTLINE(build/define_used)
#define DEFINE_DUNE_DAQ_MODULE(klass)                                                                                  \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::shared_ptr<dunedaq::appfwk::DAQModule> make(std::string n)                                                      \
  {                                                                                                                    \
    return std::shared_ptr<dunedaq::appfwk::DAQModule>(new klass(n));                                                  \
  }                                                                                                                    \
  }
 
namespace dunedaq {
 
// Disable coverage collection LCOV_EXCL_START
ERS_DECLARE_ISSUE(appfwk,
                  DAQModuleCreationFailed,
                  "Failed to create DAQModule " << instance_name << " of type " << plugin_name,
                  ((std::string)plugin_name)((std::string)instance_name))
 

ERS_DECLARE_ISSUE(appfwk, GeneralDAQModuleIssue, " DAQModule: " << name, ((std::string)name))

ERS_DECLARE_ISSUE_BASE(appfwk,
                       DAQModuleInitFailed,
                       appfwk::GeneralDAQModuleIssue,
                       " init failed.",
                       ((std::string)name),
                       ERS_EMPTY)

ERS_DECLARE_ISSUE_BASE(appfwk,
                       CommandIssue,
                       appfwk::GeneralDAQModuleIssue,
                       " Command " << cmd,
                       ((std::string)name),
                       ((std::string)cmd))

ERS_DECLARE_ISSUE_BASE(appfwk,
                       CommandRegistrationFailed,
                       appfwk::CommandIssue,
                       "Command registration failed. ",
                       ((std::string)cmd)((std::string)name),
                       ERS_EMPTY)

ERS_DECLARE_ISSUE_BASE(appfwk,
                       CommandRegistrationFailedMessage,
                       appfwk::CommandIssue,
                       "Command registration failed: " << message,
                       ((std::string)cmd)((std::string)name),
                       ((std::string)message))

ERS_DECLARE_ISSUE_BASE(appfwk,
                       UnknownCommand,
                       appfwk::CommandIssue,
                       "Command is not recognised",
                       ((std::string)cmd)((std::string)name),
                       ERS_EMPTY)

ERS_DECLARE_ISSUE_BASE(appfwk,
                       CommandFailed,
                       appfwk::CommandIssue,
                       "Command Failed. Reason " << reason,
                       ((std::string)cmd)((std::string)name),
                       ((std::string)reason))

ERS_DECLARE_ISSUE_BASE(appfwk,
                       MissingConnection,
                       appfwk::GeneralDAQModuleIssue,
                       "Required Connection Not Found. Type: " << type << ", direction: " << direction,
                       ((std::string)name),
                       ((std::string)type)((std::string)direction))
 
// Re-enable coverage collection LCOV_EXCL_STOP
namespace appfwk {

class DAQModule
  : public utilities::NamedObject
  , public opmonlib::MonitorableObject
{
public:
  class CommandData_t : public nlohmann::json {};
 
  explicit DAQModule(std::string name)
    : utilities::NamedObject(name)
  {
  }
 
  virtual ~DAQModule() noexcept = default;

  virtual void init(std::shared_ptr<ConfigurationManager> mcfg) = 0;

  void execute_command(const std::string& name, const CommandData_t& data = {});
 
  std::vector<std::string> get_commands() const;
 
  bool has_command(const std::string& name) const;
 
  void set_command_registration_allowed(bool allowed) { m_command_registration_allowed = allowed; }
 
protected:
  template<typename Child>
  void register_command(const std::string& name, void (Child::*f)(const CommandData_t&));
 
  DAQModule(DAQModule const&) = delete;
  DAQModule(DAQModule&&) = delete;
  DAQModule& operator=(DAQModule const&) = delete;
  DAQModule& operator=(DAQModule&&) = delete;
 
private:
  using CommandMap_t = std::map<std::string, std::function<void(const CommandData_t&)>>;
  CommandMap_t m_commands;
  std::atomic<bool> m_command_registration_allowed{ true };
};
 
std::shared_ptr<DAQModule>
make_module(std::string const& plugin_name, std::string const& instance_name);
 
} // namespace appfwk
 
} // namespace dunedaq
 
#include "detail/DAQModule.hxx"
 
#endif // APPFWK_INCLUDE_APPFWK_DAQMODULE_HPP_