ProcMgr.h

#ifndef BASE_PROGMGR_H
#define BASE_PROGMGR_H
 
#include <vector>
#include <map>
 
#include "base/defines.h"
#include "base/Buffer.h"
#include "base/Markers.h"
#include "base/Event.h"
 
class TTree;
class TObject;
 
namespace base {
 
   class Processor;
   class StreamProc;
   class EventProc;
   class EventStore;
 
   class ProcMgr {
 
      friend class Processor;
 
      protected:
 
         enum { MaxBrdId = 256 };
 
         enum {
            NoSyncIndex = 0xfffffffe,
            DummyIndex  = 0xffffffff
         };
 
         typedef std::map<unsigned,StreamProc*> StreamProcMap;
 
         std::string              fSecondName;         
         std::vector<StreamProc*> fProc;               
         StreamProcMap            fMap;                
         std::vector<EventProc*>  fEvProc;             
         GlobalMarksQueue         fTriggers;           
         unsigned                 fTimeMasterIndex;    
         AnalysisKind             fAnalysisKind;       
         TTree                   *fTree{nullptr};      
         int                      fDfltHistLevel;      
         int                      fDfltStoreKind;      
         base::Event             *fTrigEvent{nullptr}; 
         int                      fDebug{0};            
 
         static ProcMgr* fInstance;                     
 
         virtual unsigned SyncIdRange() const { return 0x1000000; }
 
         int SyncIdDiff(unsigned id1, unsigned id2) const;
 
         void DeleteAllProcessors();
 
      public:
         ProcMgr();
         virtual ~ProcMgr();
 
         static ProcMgr* instance();
 
         static void ClearInstancePointer(ProcMgr *mgr = nullptr);
 
         ProcMgr* AddProcessor(Processor* proc);
 
         static ProcMgr* AddProc(Processor* proc);
 
         void SetSecondName(const std::string &name = "second.C") { fSecondName = name; }
 
         void ClearSecondName() { SetSecondName(""); }
 
         const std::string &GetSecondName() const { return fSecondName; }
 
         bool RegisterProc(StreamProc* proc, unsigned kind, unsigned brdid);
 
         unsigned NumProc() const { return fProc.size(); }
 
         StreamProc* GetProc(unsigned n) const { return n < NumProc() ? fProc[n] : nullptr; }
 
         StreamProc* FindProc(const char* name) const;
 
         void SetHistFilling(int lvl);
 
         void SetDebug(int lvl = 0) { fDebug = lvl; }
         int GetDebug() const { return fDebug; }
 
         virtual void SetStoreKind(unsigned kind = 1);
 
         virtual bool InternalHistFormat() const { return true; }
 
         virtual void AddRunLog(const char *msg) {}
         virtual void AddErrLog(const char *msg) {}
         virtual bool DoLog() { return false; }
         virtual void PrintLog(const char *msg);
 
         virtual void SetSortedOrder(bool = true) {}
         virtual bool IsSortedOrder() { return false; }
 
         virtual H1handle MakeH1(const char* name, const char* title, int nbins, double left, double right, const char* xtitle = 0);
         virtual bool GetH1NBins(H1handle h1, int &nbins);
         virtual void FillH1(H1handle h1, double x, double weight = 1.);
         virtual double GetH1Content(H1handle h1, int bin);
         virtual void SetH1Content(H1handle h1, int bin, double v = 0.);
         virtual void ClearH1(H1handle h1);
         virtual void CopyH1(H1handle tgt, H1handle src);
         virtual void SetH1Title(H1handle h1, const char* title) {}
         virtual void TagH1Time(H1handle h1) {}
 
         virtual H2handle MakeH2(const char* name, const char* title, int nbins1, double left1, double right1, int nbins2, double left2, double right2, const char* options = 0);
         virtual bool GetH2NBins(H2handle h2, int &nbins1, int &nbins2);
         virtual void FillH2(H2handle h2, double x, double y, double weight = 1.);
         virtual double GetH2Content(H2handle h2, int bin1, int bin2);
         virtual void SetH2Content(H2handle h2, int bin1, int bin2, double v = 0.);
         virtual void ClearH2(H2handle h2);
         virtual void SetH2Title(H2handle h1, const char* title) {}
         virtual void TagH2Time(H2handle h2) {}
 
         virtual void ClearAllHistograms() {}
 
         virtual C1handle MakeC1(const char* name, double left, double right, base::H1handle h1 = nullptr);
         virtual void ChangeC1(C1handle c1, double left, double right);
         virtual int TestC1(C1handle c1, double value, double *dist = nullptr);
         virtual double GetC1Limit(C1handle c1, bool isleft = true);
 
         virtual bool CreateStore(const char* storename) { return false; }
         virtual bool CloseStore() { return false; }
         virtual bool CreateBranch(const char* name, const char* class_name, void** obj) { return false; }
         virtual bool CreateBranch(const char* name, void* member, const char* kind) { return false; }
         virtual bool StoreEvent() { return false; }
 
         virtual bool RegisterObject(TObject* tobj, const char* subfolder = nullptr) { return false; }
 
 
         virtual bool CallFunc(const char* funcname, void* arg) { return false; }
 
         // this is list of generic methods for common data processing
 
         bool IsRawAnalysis() const { return fAnalysisKind == kind_Raw; }
 
         void SetRawAnalysis(bool on = true) { fAnalysisKind = on ? kind_Raw : kind_Stream; }
 
         bool IsTriggeredAnalysis() const { return fAnalysisKind == kind_Triggered; }
 
         void SetTriggeredAnalysis(bool on = true) { fAnalysisKind = on ? kind_Triggered : kind_Stream; }
 
         bool IsStreamAnalysis() const { return fAnalysisKind == kind_Stream; }
 
         void SetTimeSorting(bool on);
 
         void SetTimeMasterIndex(unsigned indx) { fTimeMasterIndex = indx; }
 
         void ProvideRawData(const Buffer& buf);
 
         bool AnalyzeSyncMarkers();
 
         bool CollectNewTriggers();
 
         bool ScanDataForNewTriggers();
 
         bool AnalyzeNewData(base::Event* &evt);
 
         bool HasTrigEvent() const { return fTrigEvent != nullptr; }
 
         bool AddToTrigEvent(const std::string& name, base::SubEvent* sub);
 
         bool ProduceNextEvent(base::Event* &evt);
 
         virtual bool ProcessEvent(base::Event* evt);
 
         void UserPreLoop(Processor* only_proc = nullptr, bool call_when_running = false);
 
         void UserPostLoop(Processor* only_proc = nullptr);
   };
}
 
#endif