DataStore.hpp

Go to the documentation of this file.

 
// 09-Sep-2020, KAB: the initial version of this class was based on the
// Queue interface from the appfwk repo.
 
#ifndef DFMODULES_INCLUDE_DFMODULES_DATASTORE_HPP_
#define DFMODULES_INCLUDE_DFMODULES_DATASTORE_HPP_
 
#include "appfwk/ConfigurationManager.hpp"
#include "cetlib/BasicPluginFactory.h"
#include "cetlib/compiler_macros.h"
#include "daqdataformats/TimeSlice.hpp"
#include "daqdataformats/TriggerRecord.hpp"
#include "daqdataformats/Types.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 "nlohmann/json.hpp"
 
#include <chrono>
#include <cstddef>
#include <memory>
#include <string>
#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_DATA_STORE(klass)                                                                                  \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::shared_ptr<dunedaq::dfmodules::DataStore> make(const std::string& name,                                         \
                                                      std::shared_ptr<dunedaq::appfwk::ConfigurationManager> mcfg,     \
                                                      const std::string& writer_name)                                  \
  {                                                                                                                    \
    return std::shared_ptr<dunedaq::dfmodules::DataStore>(new klass(name, mcfg, writer_name));                         \
  }                                                                                                                    \
  }
 
namespace dunedaq {

ERS_DECLARE_ISSUE(dfmodules,                                                             
                  DataStoreCreationFailed,                                               
                  "Failed to create DataStore " << plugin_name << " with name " << name, 
                  ((std::string)plugin_name)((std::string)name)                          
)

ERS_DECLARE_ISSUE(dfmodules,
                  RetryableDataStoreProblem,
                  "Module " << mod_name << ": A problem was encountered when " << description,
                  ((std::string)mod_name)((std::string)description))

ERS_DECLARE_ISSUE(dfmodules,
                  IgnorableDataStoreProblem,
                  "Module " << mod_name << ": A problem was encountered when " << description,
                  ((std::string)mod_name)((std::string)description))
 
namespace dfmodules {

class DataStore
  : public utilities::NamedObject
  , public opmonlib::MonitorableObject
{
public:
  explicit DataStore(const std::string& name)
    : utilities::NamedObject(name)
    , MonitorableObject()
  {
  }

  virtual void write(const daqdataformats::TriggerRecord& tr) = 0;

  virtual void write(const daqdataformats::TimeSlice& ts) = 0;

  virtual void prepare_for_run(daqdataformats::run_number_t run_number, bool run_is_for_test_purposes) = 0;

  virtual void finish_with_run(daqdataformats::run_number_t run_number) = 0;
 
private:
  DataStore(const DataStore&) = delete;
  DataStore& operator=(const DataStore&) = delete;
  DataStore(DataStore&&) = delete;
  DataStore& operator=(DataStore&&) = delete;
};

inline std::shared_ptr<DataStore>
make_data_store(const std::string& type,
                const std::string& name,
                std::shared_ptr<dunedaq::appfwk::ConfigurationManager> mcfg,
                const std::string& writer_identifier)
{
  static cet::BasicPluginFactory bpf("duneDataStore", "make"); // NOLINT
 
  std::shared_ptr<DataStore> ds;
  try {
    ds = bpf.makePlugin<std::shared_ptr<DataStore>>(type, name, mcfg, writer_identifier);
  } catch (const cet::exception& cexpt) {
    throw DataStoreCreationFailed(ERS_HERE, type, name, cexpt);
  }
 
  return ds;
}
 
} // namespace dfmodules
} // namespace dunedaq
 
#endif // DFMODULES_INCLUDE_DFMODULES_DATASTORE_HPP_