QBaseModule.hh

Go to the documentation of this file.

#ifndef _Q_BASE_MODULE_H_
#define _Q_BASE_MODULE_H_
#include <string>
#include <sstream>
#include <stdarg.h>
 
#include "QMessage.hh"
#include "QDiana.hh"
#include "QSequence.hh"
#include "QGeneralFactory.hh"
#include "QBaseModuleFactory.hh"
#include "QModuleConfig.hh"
#include "QEventLabel.hh"
#include "QModuleTimeProfiling.hh"
 
Q_BEGIN_NAMESPACE
 
class QEventAssembler;
class QEventList;
 
class QBaseModule : protected QModuleTimeProfiling  {
 
    public:
        enum Type {
            Module,
            Filter,
            Reader,
            Writer,
            Driver,
        };
 
 
        QBaseModule(Type type);
 
        virtual ~QBaseModule();
        double GetDouble(const std::string& parname, double defVal, bool warnCfg = true) const;
        std::vector<double> GetVectorDouble(const std::string& parname, std::vector<double> defVal, bool warnCfg = true) const;
 
        int GetInt(const std::string& parname, int defVal, bool warnCfg = true) const;
        std::vector<int> GetVectorInt(const std::string& parname, std::vector<int> defVal, bool warnCfg = true) const;
 
        bool GetBool(const std::string& parname, bool defVal, bool warnCfg = true) const;
        std::vector<bool> GetVectorBool(const std::string& parname, std::vector<bool> defVal, bool warnCfg = true) const;
 
        const std::string& GetString(const std::string& parname, const std::string& defVal, bool warnCfg = true) const;
        std::vector<std::string> GetVectorString(const std::string& parname, std::vector<std::string> defVal, bool warnCfg = true) const;
 
        inline void Debug(const char* descr, ...) const; 
        inline void Info(const char* descr, ...) const; 
        inline void Warn(const char* descr, ...) const; 
        inline void Error(const char* descr, ...) const; 
        inline void Panic(const char* descr, ...) const; 
 
        const QGlobalDataManager& GlobalData() const {return GetSequence().GlobalData();}
        bool GetRunAgain() const { return my_sequence->GetRunAgain();}
        void SetRunAgain(bool b) { my_sequence->SetRunAgain(b);}
        unsigned int GetIteration() const { return my_sequence->GetIteration(); }
 
        unsigned int GetOccurrence() const {return fOccurrence;}
        inline bool isEnabled() const { return fEnabled;}
        std::string GetFullPath() const;
        const std::string& GetName() const  { return fName; }
        const std::string& GetLabel() const  { return fLabel; }
        MsgLevel GetVerbosity() {return verbosity;}
        const QSequence& GetSequence() const {return *my_sequence;}
        void Update(QSequence* s, unsigned int occurrence);
        bool NeedNeighbours() { return fNeedNeighbours;}
 
        void BeginBase(QEventAssembler& ev);
        virtual void Begin(QEventAssembler& ev) = 0;
 
        bool ProcessBase(QEventAssembler& ev, QEventList& evl, const bool exec, QEventList& ovl);
        virtual bool Process(QEventAssembler& ev, QEventList& evl, const bool exec,QEventList& ovl) = 0;
 
        void EndBase();
        virtual void End() = 0;
 
        const std::vector<QEventLabel>& GetRequiredLabels() const { return fRequiredLabels; }
 
 
    protected:
        bool fExecuted;
        
        QModuleConfig& GetConfig() { return fConfig; }
 
        void SetNeedNeighbours(bool need) {fNeedNeighbours = need;}
 
    private:
        void UpdateEnableFlag() { fEnabled = GetBool("enable",false); }
 
        void Disable() { fEnabled = false; }
 
        void UpdateConfigParameters(const std::string& p) const;
 
 
        MsgLevel verbosity;
        unsigned int fOccurrence;
        bool fEnabled;
        std::string fLabel;
        std::string fName;
        std::string fMessageName;
        bool fFirstCall;
        bool fNeedNeighbours;
        QSequence *my_sequence;
        mutable QModuleConfig fConfig;
        Type fType;
        std::vector<QEventLabel> fRequiredLabels;
 
        void SetVerbosity(MsgLevel l=WarnMsg) { verbosity=l; }
 
        template<class T> friend class QModFactory;
 
        friend class QModuleFactory;
        friend class QSequence;
        friend class QModule;
        friend class QWriter;
        friend class QDriver;
        friend class QFilter;
 
};
 
inline void QBaseModule::Debug(const char* descr, ...) const {
    if (verbosity <= DebugMsg ){
        char buf[4096];  
        va_list args;
        va_start(args,descr);
        vsnprintf(buf,4096,descr,args);
        QMessageHandler::Get()->Send(DebugMsg, fMessageName, buf);
    }
}
 
inline void QBaseModule::Info(const char* descr, ...)const  {
    if (verbosity <= InfoMsg ){
        char buf[4096];  
        va_list args;
        va_start(args,descr);
        vsnprintf(buf,4096, descr,args);
        QMessageHandler::Get()->Send(InfoMsg, fMessageName, buf);
    }
}
 
inline void QBaseModule::Warn(const char* descr, ...)const  {
    if (verbosity <= WarnMsg ){
        char buf[4096];  
        va_list args;
        va_start(args,descr);
        vsnprintf(buf,4096,descr,args);
        QMessageHandler::Get()->Send(WarnMsg, fMessageName, buf);
    }
}
 
inline void QBaseModule::Error(const char* descr, ...)const  {
    if (verbosity <= ErrorMsg ){
        char buf[4096];  
        va_list args;
        va_start(args,descr);
        vsnprintf(buf,4096,descr,args);
        QMessageHandler::Get()->Send(ErrorMsg, fMessageName, buf);
    }
}
 
inline void QBaseModule::Panic(const char* descr, ...)const  {
    if (verbosity <= PanicMsg ){
        char buf[4096];  
        va_list args;
        va_start(args,descr);
        vsnprintf(buf,4096,descr,args);
        QMessageHandler::Get()->Send(PanicMsg, fMessageName, buf);
    }
}
 
Q_END_NAMESPACE
 
#endif