newmonitor/base/ProcMgr.h (r3879/r3878)

Go to the documentation of this file.

#ifndef BASE_PROGMGR_H
#define BASE_PROGMGR_H

#include <vector>
#include <map>

#include "base/Buffer.h"
#include "base/StreamProc.h"
#include "base/Event.h"

namespace base {

   class ProcMgr {
      protected:

         enum { MaxBrdId = 256 };

         enum {
            NoSyncIndex = 0xfffffffe,
            DummyIndex  = 0xffffffff
         };

         typedef std::vector<StreamProc*> ProcessorsVect;
         typedef std::map<unsigned,StreamProc*> ProcessorsMap;

         ProcessorsVect fProc;                      
         ProcessorsMap  fMap;                       

         GlobalTriggerMarksQueue  fTriggers;        

         unsigned  fTimeMasterIndex;                

         bool      fRawAnalysisOnly;                

         static ProcMgr* fInstance;                 

         virtual unsigned SyncIdRange() const { return 0x1000000; }

         int SyncIdDiff(unsigned id1, unsigned id2) const;

      public:
         ProcMgr();
         virtual ~ProcMgr();

         static ProcMgr* instance();

         static ProcMgr* AddProc(StreamProc* proc);

         bool RegisterProc(StreamProc* proc, unsigned kind, unsigned brdid);

         unsigned NumProc() const { return fProc.size(); }
         StreamProc* GetProc(unsigned n) const { return n<NumProc() ? fProc[n] : 0; }

         virtual H1handle MakeH1(const char* name, const char* title, int nbins, double left, double right, const char* xtitle = 0) { return 0; }
         virtual void FillH1(H1handle h1, double x, double weight = 1.) {}

         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) { return 0; }
         virtual void FillH2(H1handle h2, double x, double y, double weight = 1.) {}

         virtual C1handle MakeC1(const char* name, double left, double right, base::H1handle h1 = 0) { return 0; }
         virtual void ChangeC1(C1handle c1, double left, double right) {}
         virtual int TestC1(C1handle c1, double value, double* dist = 0) { return false; }
         virtual double GetC1Limit(C1handle c1, bool isleft = true) { return 0; }

         // this is list of generic methods for common data processing

         bool IsRawAnalysis() const { return fRawAnalysisOnly; }
         void SetRawAnalysis(bool on) { fRawAnalysisOnly = on; }

         void SetTimeSorting(bool on);

         void SetTimeMasterIndex(unsigned indx) { fTimeMasterIndex = indx; }

         void ProvideRawData(const Buffer& buf);

         void ScanNewData();

         bool SkipAllData();


         bool AnalyzeSyncMarkers();

         bool CollectNewTriggers();

         bool ScanDataForNewTriggers();


         bool ProduceNextEvent(base::Event* &evt);
   };
}

#endif