OpMonFacility.hpp

Go to the documentation of this file.

 
#ifndef OPMONLIB_INCLUDE_OPMONLIB_OPMONFACILITY_HPP_
#define OPMONLIB_INCLUDE_OPMONLIB_OPMONFACILITY_HPP_
 
#include "Issues.hpp"
 
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
#include "opmonlib/opmon_entry.pb.h"
#include <cetlib/BasicPluginFactory.h>
#include <cetlib/compiler_macros.h>
 
#include <iostream>
#include <memory>
#include <optional>
#include <string>
 
#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_OPMON_FACILITY(klass)                                                                              \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::shared_ptr<dunedaq::opmonlib::OpMonFacility> make(std::string facility,                                         \
                                                         std::optional<dunedaq::opmon::OpMonId> o)                     \
  {                                                                                                                    \
    return std::shared_ptr<dunedaq::opmonlib::OpMonFacility>(new klass(facility, o));                                  \
  }                                                                                                                    \
  }
 
namespace dunedaq {
 
ERS_DECLARE_ISSUE(opmonlib,
                  OpMonPublishFailure,
                  uri << " Failed to publish " << measurment << " from " << opmon_id,
                  ((std::string)uri)((std::string)measurment)((std::string)opmon_id))
 
}
 
namespace dunedaq::opmonlib {
 
class OpMonFacility
{
public:
  explicit OpMonFacility(std::string uri)
    : m_uri(uri)
  {
    ;
  }
 
  virtual ~OpMonFacility() = default;
  OpMonFacility(const OpMonFacility&) = delete;            
  OpMonFacility& operator=(const OpMonFacility&) = delete; 
  OpMonFacility(OpMonFacility&&) = delete;                 
  OpMonFacility& operator=(OpMonFacility&&) = delete;      
 
  const auto& get_URI() const { return m_uri; }
 
  // Publish information
  virtual void publish(opmon::OpMonEntry&&) const = 0;
 
private:
  std::string m_uri;
};
 
using OptionalOrigin = std::optional<dunedaq::opmon::OpMonId>;
std::shared_ptr<OpMonFacility>
makeOpMonFacility(std::string const& facility, OptionalOrigin = OptionalOrigin());
 
} // namespace dunedaq::opmonlib
 
#endif // OPMONLIB_INCLUDE_OPMONLIB_OPMONFACILITY_HPP_