Process.h

#ifndef FIRE_PROCESS_H
#define FIRE_PROCESS_H
 
#include "fire/logging/Logger.h"
#include "fire/StorageControl.h"
#include "fire/Conditions.h"
#include "fire/Event.h"
#include "fire/Processor.h"
#include "fire/RunHeader.h"
 
namespace fire {
 
class Process {
 public:
  Process(const config::Parameters& configuration);
  
  ~Process();
  
  void run(); 
 
  const EventHeader& eventHeader() const {
    return event_.header();
  }
 
  EventHeader& eventHeader() {
    return event_.header();
  }
 
  const RunHeader& runHeader() const {
    assert(run_header_);
    return *run_header_;
  }
 
  RunHeader& runHeader() {
    assert(run_header_);
    return *run_header_;
  }
 
  void addStorageControlHint(
      StorageControl::Hint hint,
      const std::string& purpose,
      const std::string& processor
      ) {
    storage_control_.addHint(hint,purpose,processor);
  }
 
  Conditions& conditions() {
    return *conditions_;
  }
 
 private:
  void newRun(RunHeader& rh);
 
  bool process(const std::size_t& n_events_processed);
 
 private:
  int event_limit_;
 
  int log_frequency_;
 
  int max_tries_;
 
  int run_;
 
  std::vector<std::string> input_files_;
 
  io::Writer output_file_;
 
  std::vector<std::unique_ptr<Processor>> sequence_;
 
  StorageControl storage_control_;
 
  std::unique_ptr<Conditions> conditions_;
 
  Event event_;
 
  RunHeader* run_header_;
 
  ENABLE_LOGGING(Process);
};  // Process
 
}  // namespace fire
 
#endif  // FIRE_PROCESS_H