RunStore.hh

 
#ifndef __RAT_DS_RunStore__
#define __RAT_DS_RunStore__
 
#include <TTree.h>
 
#include <RAT/DS/Run.hh>
#include <map>
 
namespace RAT {
namespace DS {
 
class RunStore;
class Root;
 
class RunRecord {
 public:
  RunRecord() : run(0), writtenToDisk(false) {}
  ~RunRecord() { delete run; }
  Run *run;
  bool writtenToDisk;
};
 
class RunStore {
 public:
  inline static RunStore *Get() {
    if (!fgStore) {
      fgStore = new RunStore();
    }
    return fgStore;
  }
 
  inline static Run *GetRun(Root *ds) { return Get()->InstanceGetRun(ds); }
 
  inline static Run *GetRun(int runID) { return Get()->InstanceGetRun(runID); }
 
  inline static Run *GetCurrentRun() { return Get()->InstanceGetRun(currentRunID); }
 
  inline static void SetReadTree(TTree *tree) { Get()->InstanceSetReadTree(tree); }
 
  inline static void SetWriteTree(TTree *tree) { Get()->InstanceSetWriteTree(tree); }
 
  inline static void FlushWriteTree() { Get()->InstanceFlushWriteTree(); }
 
  inline static void AddNewRun(Run *run) {
    currentRunID = run->GetID();
    Get()->InstanceAddNewRun(run);
  }
 
  inline static void PreloadFromTree(TTree *tree, bool alreadyWrittenToDisk = false) {
    Get()->InstancePreloadFromTree(tree, alreadyWrittenToDisk);
  }
 
 protected:
  static RunStore *fgStore;
  static int currentRunID;
 
 public:
  RunStore();
  virtual ~RunStore();
 
  Run *InstanceGetRun(Root *ds);
  Run *InstanceGetRun(int runID);
  void InstanceSetReadTree(TTree *tree);
  void InstanceSetWriteTree(TTree *tree);
  void InstanceFlushWriteTree();
  void InstanceAddNewRun(Run *run);
  void InstancePreloadFromTree(TTree *tree, bool writtenToDisk = false);
 
  ClassDef(RunStore, 2);
 
 protected:
  TTree *fReadTree;
  Run *fReadRun;
  TTree *fWriteTree;
  Run *fWriteRun;
  std::map<int, RunRecord *> fCache;
};
 
}  // namespace DS
}  // namespace RAT
 
#endif