Processor.h

#ifndef FIRE_PROCESSOR_H
#define FIRE_PROCESSOR_H
 
#include "fire/Conditions.h"
#include "fire/Event.h"
#include "fire/RunHeader.h"
#include "fire/StorageControl.h"
#include "fire/config/Parameters.h"
#include "fire/exception/Exception.h"
#include "fire/factory/Factory.h"
#include "fire/logging/Logger.h"
 
namespace fire {
 
class Process;
 
class Processor {
 public:
  class AbortEventException : public std::exception {
   public:
    AbortEventException() noexcept : std::exception() {}
  };
 
 public:
  Processor(const config::Parameters &ps);
 
  virtual ~Processor() = default;
 
  virtual void beforeNewRun(RunHeader &header) {}
 
  virtual void onNewRun(const RunHeader &runHeader) {}
 
  virtual void onFileOpen(const std::string &file_name) {}
 
  virtual void onFileClose(const std::string &file_name) {}
 
  virtual void onProcessStart() {}
 
  virtual void onProcessEnd() {}
 
  const std::string &getName() const { return name_; }
 
 
  virtual void process(Event &event) = 0;
 
  virtual void attach(Process *p) final { process_ = p; }
 
  template <class T>
  const T &getCondition(const std::string &condition_name) {
    return getConditions().get<T>(condition_name);
  }
 public:
  class Factory {
   public:
    using PrototypePtr = std::unique_ptr<Processor>;
 
    using PrototypeMaker = std::function<PrototypePtr(const config::Parameters&,Process&)>;
  
   public:
    static Factory& get() {
      static Factory the_factory;
      return the_factory;
    }
  
    template<typename DerivedType>
    uint64_t declare() {
      std::string full_name{boost::core::demangle(typeid(DerivedType).name())};
      library_[full_name] = &maker<DerivedType>;
      return reinterpret_cast<std::uintptr_t>(&library_);
    }
  
    PrototypePtr make(const std::string& full_name,
                      const config::Parameters& ps,
                      Process& p) {
      auto lib_it{library_.find(full_name)};
      if (lib_it == library_.end()) {
        throw Exception("Factory","A processor of class " + full_name +
                         " has not been declared.",false);
      }
      return lib_it->second(ps,p);
    }
  
    Factory(Factory const&) = delete;
  
    void operator=(Factory const&) = delete;
  
   private:
    template <typename DerivedType>
    static PrototypePtr maker(const config::Parameters& parameters, Process& process) {
      std::unique_ptr<Processor> ptr;
      if constexpr (std::is_constructible<DerivedType, const config::Parameters&>::value) {
        // new type
        ptr = std::make_unique<DerivedType>(parameters);
        ptr->attach(&process);
      } else {
        // old type
        ptr = std::make_unique<DerivedType>(parameters.get<std::string>("name"), process);
        dynamic_cast<DerivedType*>(ptr.get())->configure(const_cast<config::Parameters&>(parameters));
      }
      return ptr;
    }
  
    Factory() = default;
  
    std::unordered_map<std::string, PrototypeMaker> library_;
  };  // Factory
 
 protected:
  void setStorageHint(StorageControl::Hint hint,
                      const std::string &purpose = "") const;
 
 
  void abortEvent() { throw AbortEventException(); }
 
  inline void fatalError(const std::string &msg) { throw Exception(name_, msg); }
 
  mutable logging::logger theLog_;
 
 private:
  Conditions &getConditions() const;
 
  std::string name_;
 
  Process *process_{nullptr};
};
 
}  // namespace fire
 
#define DECLARE_PROCESSOR(CLASS)                             \
  namespace {                                                \
  auto v = fire::Processor::Factory::get().declare<CLASS>(); \
  }
 
#endif