ConditionsObjectProvider.h

Go to the documentation of this file.

 
#ifndef FRAMEWORK_CONDITIONSOBJECTPROVIDER_H_
#define FRAMEWORK_CONDITIONSOBJECTPROVIDER_H_
 
/*~~~~~~~~~~~*/
/*   Event   */
/*~~~~~~~~~~~*/
#include "Framework/Exception/Exception.h"
 
/*~~~~~~~~~~~~~~~*/
/*   Framework   */
/*~~~~~~~~~~~~~~~*/
#include "Framework/ConditionsIOV.h"
#include "Framework/ConditionsObject.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Logger.h"
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <map>
 
namespace ldmx {
class EventHeader;
class RunHeader;
}  // namespace ldmx
 
namespace framework {
 
class Process;
class ConditionsObjectProvider;
 
typedef ConditionsObjectProvider* ConditionsObjectProviderMaker(
    const std::string& objname, const std::string& tagname,
    const framework::config::Parameters& params, Process& process);
 
class ConditionsObjectProvider {
 public:
  static const int CLASSTYPE{10};
 
  ConditionsObjectProvider(const std::string& objname,
                           const std::string& tagname,
                           const framework::config::Parameters& parameters,
                           Process& process);
 
  virtual ~ConditionsObjectProvider() { ; }
 
  virtual std::pair<const ConditionsObject*, ConditionsIOV> getCondition(
      const ldmx::EventHeader& context) = 0;
 
  virtual void releaseConditionsObject(const ConditionsObject* co) {
    delete co;
  }
 
  virtual void onProcessStart() {}
 
  virtual void onProcessEnd() {}
 
  virtual void onNewRun(ldmx::RunHeader&) {}
 
  const std::string& getConditionObjectName() const { return objectName_; }
 
  static void declare(const std::string& classname,
                      ConditionsObjectProviderMaker*);
 
  const std::string& getTagName() const { return tagname_; }
 
 protected:
  std::pair<const ConditionsObject*, ConditionsIOV> requestParentCondition(
      const std::string& name, const ldmx::EventHeader& context);
 
  logging::logger theLog_;
 
  const Process& process() const { return process_; }
 
 private:
  Process& process_;
 
  std::string objectName_;
 
  std::string tagname_;
};
 
}  // namespace framework
 
#define DECLARE_CONDITIONS_PROVIDER(CLASS)                                    \
  framework::ConditionsObjectProvider* CLASS##_ldmx_make(                     \
      const std::string& name, const std::string& tagname,                    \
      const framework::config::Parameters& params,                            \
      framework::Process& process) {                                          \
    return new CLASS(name, tagname, params, process);                         \
  }                                                                           \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {     \
    framework::ConditionsObjectProvider::declare(#CLASS, &CLASS##_ldmx_make); \
  }
 
#define DECLARE_CONDITIONS_PROVIDER_NS(NS, CLASS)                           \
  framework::ConditionsObjectProvider* CLASS##_ldmx_make(                   \
      const std::string& name, const std::string& tagname,                  \
      const framework::config::Parameters& params,                          \
      framework::Process& process) {                                        \
    return new NS::CLASS(name, tagname, params, process);                   \
  }                                                                         \
  __attribute__((constructor(1000))) static void CLASS##_ldmx_declare() {   \
    framework::ConditionsObjectProvider::declare(                           \
        std::string(#NS) + "::" + std::string(#CLASS), &CLASS##_ldmx_make); \
  }
 
#endif