Module.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/ModuleParamList.h>
#include <framework/core/ModuleParamList.templateDetails.h>
#include <framework/core/ModuleCondition.h>
#include <framework/core/PathElement.h>
 
#include <framework/logging/LogConfig.h>
 
#include <list>
#include <string>
#include <memory>
 
namespace boost {
  namespace python {
    class list;
    class dict;
    namespace api {
      class object;
    }
    using api::object;
  }
}
 
namespace Belle2 {
  class Module;
  class Path;
 
  typedef std::shared_ptr<Module> ModulePtr;
 
  class Module : public PathElement {
 
  public:
 
    enum EModulePropFlags {
      c_Input                       = 1,  
      c_Output                      = 2,  
      c_ParallelProcessingCertified = 4,  
      c_HistogramManager            = 8, 
      c_InternalSerializer          = 16,  
      c_TerminateInAllProcesses     = 32,  
      c_DontCollectStatistics       = 64,  
    };
 
    typedef ModuleCondition::EAfterConditionPath EAfterConditionPath;
 
    Module();
 
    virtual void initialize() {};
 
    virtual std::vector<std::string> getFileNames(__attribute__((unused)) bool outputFiles)
    {
      return std::vector<std::string>();
    }
 
    virtual void beginRun() {};
 
    virtual void event() {};
 
    virtual void endRun() {};
 
    virtual void terminate() {};
 
    const std::string& getName() const {return m_name;}
 
    const std::string& getType() const;
 
    const std::string& getPackage() const {return m_package;}
 
    const std::string& getDescription() const {return m_description;}
 
    void setName(const std::string& name) { m_name = name; };
    void setPropertyFlags(unsigned int propertyFlags);
 
    LogConfig& getLogConfig() {return m_logConfig;}
 
    void setLogConfig(const LogConfig& logConfig) {m_logConfig = logConfig;}
 
    void setLogLevel(int logLevel);
 
    void setDebugLevel(int debugLevel);
 
    void setAbortLevel(int abortLevel);
 
    void setLogInfo(int logLevel, unsigned int logInfo);
 
 
    void if_value(const std::string& expression, const std::shared_ptr<Path>& path,
                  EAfterConditionPath afterConditionPath = EAfterConditionPath::c_End);
 
    void if_false(const std::shared_ptr<Path>& path, EAfterConditionPath afterConditionPath = EAfterConditionPath::c_End);
 
    void if_true(const std::shared_ptr<Path>& path, EAfterConditionPath afterConditionPath = EAfterConditionPath::c_End);
 
    bool hasCondition() const { return not m_conditions.empty(); };
 
    const ModuleCondition* getCondition() const
    {
      if (m_conditions.empty()) {
        return nullptr;
      } else {
        return &m_conditions.front();
      }
    }
 
    const std::vector<ModuleCondition>& getAllConditions() const
    {
      return m_conditions;
    }
 
    bool evalCondition() const;
 
    std::shared_ptr<Path> getConditionPath() const;
 
    Module::EAfterConditionPath getAfterConditionPath() const;
 
    std::vector<std::shared_ptr<Path>> getAllConditionPaths() const;
 
    bool hasProperties(unsigned int propertyFlags) const;
 
    bool hasUnsetForcedParams() const;
 
    const ModuleParamList& getParamList() const { return m_moduleParamList; }
 
    template<typename T>
    ModuleParam<T>& getParam(const std::string& name) const;
 
    bool hasReturnValue() const { return m_hasReturnValue; }
    int getReturnValue() const { return m_returnValue; }
 
    std::shared_ptr<PathElement> clone() const override;
 
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //                   Python API
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    std::shared_ptr<boost::python::list> getParamInfoListPython() const;
 
    static void exposePythonAPI();
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
  protected:
 
    virtual void def_initialize() { initialize(); }
 
    virtual void def_beginRun() { beginRun(); }
 
    virtual void def_event() { event(); }
 
    virtual void def_endRun() { endRun(); }
 
    virtual void def_terminate() { terminate(); }
 
 
    void setDescription(const std::string& description);
 
    void setType(const std::string& type);
 
    template<typename T>
    void addParam(const std::string& name, T& paramVariable, const std::string& description, const T& defaultValue);
 
    template<typename T>
    void addParam(const std::string& name, T& paramVariable, const std::string& description);
 
    void setReturnValue(int value);
 
    void setReturnValue(bool value);
 
    void setParamList(const ModuleParamList& params) { m_moduleParamList = params; }
 
 
  private:
    std::list<ModulePtr> getModules() const override { return std::list<ModulePtr>(); }
 
    std::string m_name;           
    std::string m_type;           
    std::string m_package;        
    std::string m_description;    
    unsigned int m_propertyFlags; 
    LogConfig m_logConfig;        
    ModuleParamList m_moduleParamList; 
    bool m_hasReturnValue;     
    int  m_returnValue;        
    std::vector<ModuleCondition> m_conditions; 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //                    Python API
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    std::string getPathString() const override;
 
    void setParamPython(const std::string& name, const boost::python::object& pyObj);
 
    void setParamPythonDict(const boost::python::dict& dictionary);
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    friend class ModuleProxyBase;
  };
 
 
  //------------------------------------------------------
  //       Implementation of template based methods
  //------------------------------------------------------
  template<typename T>
  void Module::addParam(const std::string& name, T& paramVariable, const std::string& description, const T& defaultValue)
  {
    m_moduleParamList.addParameter(name, paramVariable, description, defaultValue);
  }
 
 
  template<typename T>
  void Module::addParam(const std::string& name, T& paramVariable, const std::string& description)
  {
    m_moduleParamList.addParameter(name, paramVariable, description);
  }
 
  template<typename T>
  ModuleParam<T>& Module::getParam(const std::string& name) const
  {
    return m_moduleParamList.getParameter<T>(name);
  }
 
 
  //------------------------------------------------------
  //             Define convenient typdefs
  //------------------------------------------------------
 
  typedef std::list<ModulePtr> ModulePtrList;
 
 
  //------------------------------------------------------
  //  Proxy class for creating an instance of the module
  //------------------------------------------------------
  class ModuleProxyBase {
 
  public:
    ModuleProxyBase(std::string  moduleType, std::string  package);
 
    virtual ~ModuleProxyBase() {};
 
    ModulePtr createModule() const
    {
      ModulePtr nm(createInstance());
      nm->setType(m_moduleType);
      nm->setName(m_moduleType);
      nm->m_package = m_package;
      return nm;
    }
 
    const std::string& getModuleName() const {return m_moduleType; }
 
 
  protected:
    virtual Module* createInstance() const = 0;
 
    std::string m_moduleType; 
    std::string m_package; 
  };
 
 
#ifndef _PACKAGE_
#define _PACKAGE_ "" 
#endif
 
  //------------------------------------------------------
  //             Define convenient macro
  //------------------------------------------------------
#define REG_MODULE(moduleName) namespace { struct ModuleProxy##moduleName: public ModuleProxyBase { \
      ModuleProxy##moduleName(): ModuleProxyBase(#moduleName, "" _PACKAGE_) {} \
      virtual ::Belle2::Module* createInstance() const override final { return new moduleName##Module(); } \
    } proxy##moduleName##Module; }
 
} // end namespace Belle2