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 <cetlib/BasicPluginFactory.h>
#include <cetlib/compiler_macros.h>
#include "opmonlib/opmon_entry.pb.h"
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
 
#include <iostream>
#include <memory>
#include <string>
#include <optional>
 
#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_