VModule.h

Go to the documentation of this file.

#ifndef _fwk_VModule_h_
#define _fwk_VModule_h_

#include <utl/ObjectRegistrar.h>
#include <utl/ObjectFactory.h>
#include <utl/ErrorLogger.h>
#include <utl/Stopwatch.h>

#include <boost/algorithm/string.hpp>

#include <string>


namespace evt {
  class Event;
}

namespace fwk {

  class VModule;

  typedef utl::ObjectFactory<VModule*, std::string> VModuleFactory;


  class VModule {

  public:
    VModule() = default;
    virtual ~VModule() = default;

    enum ResultFlag {
      eSuccess,
      eFailure,
      eBreakLoop,
      eContinueLoop
    };

    static std::string GetResultFlagByName(const ResultFlag flag);


    virtual ResultFlag Init() = 0;


    virtual ResultFlag Run(evt::Event& event) = 0;


    virtual ResultFlag Finish() = 0;

    void InitTiming() { fStopwatch.Reset(); }

    ResultFlag
    RunWithTiming(evt::Event& event)
    {
      fStopwatch.Start();
      const ResultFlag flag = this->Run(event);
      fStopwatch.Stop();
      return flag;
    }

    utl::Stopwatch& GetStopwatch() { return fStopwatch; }
    const utl::Stopwatch& GetStopwatch() const { return fStopwatch; }

    enum VersionInfoType {
      eFilename = 1,
      eRevisionNumber = 2,
      eDate = 3,
      eTime = 4,
      eLastEditor = 5
    };

    std::string GetVersionInfo(const VersionInfoType v) const;

  protected:
    // Module specific verbosity level (used in Radio module)
    int fInfoLevel = 0;

    enum InfoLevel {
      eInfoNone = 0,
      eInfoFinal = 1,
      eInfoIntermediate = 2,
      eInfoDebug = 3
    };

  private:
    // prevent copying
    VModule(const VModule&);
    VModule& operator=(const VModule&);

    utl::Stopwatch fStopwatch;

  };


}


#define REGISTER_MODULE(_moduleName_, _ModuleType_)                      \
public:                                                                  \
  static std::string GetRegistrationId()                                 \
  { return _moduleName_; }                                               \
                                                                         \
  static                                                                 \
  fwk::VModule*                                                          \
  Create()                                                               \
  {                                                                      \
    static _ModuleType_ module;                                          \
    return &module;                                                      \
  }                                                                      \
                                                                         \
private:                                                                 \
  utl::ObjectRegistrar<_ModuleType_, fwk::VModuleFactory> fAutoModuleReg

#define INFOFinal(y) if (InfoLevel::eInfoFinal <= fInfoLevel) INFO(y)
#define INFOIntermediate(y) if (InfoLevel::eInfoIntermediate <= fInfoLevel) INFO(y)
#define INFODebug(y) if (InfoLevel::eInfoDebug <= fInfoLevel) INFO(y)


#endif