ConditionsProvider.h

#ifndef FIRE_CONDITIONSPROVIDER_H
#define FIRE_CONDITIONSPROVIDER_H
 
#include <map>
 
#include "fire/ConditionsIntervalOfValidity.h"
#include "fire/ConditionsObject.h"
#include "fire/RunHeader.h"
#include "fire/config/Parameters.h"
#include "fire/exception/Exception.h"
#include "fire/factory/Factory.h"
#include "fire/logging/Logger.h"
 
namespace fire {
 
class Conditions;
 
class ConditionsProvider {
 public:
  using Factory =
      factory::Factory<ConditionsProvider, std::shared_ptr<ConditionsProvider>,
                       const config::Parameters&>;
  ConditionsProvider(const fire::config::Parameters& ps);
 
  virtual ~ConditionsProvider() = default;
 
  virtual std::pair<const ConditionsObject*, ConditionsIntervalOfValidity>
  getCondition(const EventHeader& context) = 0;
 
  virtual void release(const ConditionsObject* co) { delete co; }
 
  virtual void onProcessStart() {}
 
  virtual void onProcessEnd() {}
 
  virtual void onNewRun(RunHeader&) {}
 
  const std::string& getConditionObjectName() const { return objectName_; }
 
  const std::string& getTagName() const { return tagname_; }
 
  virtual void attach(Conditions* c) final { conditions_ = c; }
 
 protected:
  std::pair<const ConditionsObject*, ConditionsIntervalOfValidity>
  requestParentCondition(const std::string& name, const EventHeader& context);
 
  mutable logging::logger theLog_;
 
 private:
  Conditions* conditions_{nullptr};
 
  std::string objectName_;
 
  std::string tagname_;
};
 
}  // namespace fire
 
#define DECLARE_CONDITIONS_PROVIDER(CLASS)                            \
  namespace {                                                         \
  auto v = fire::ConditionsProvider::Factory::get().declare<CLASS>(); \
  }
 
#endif