AsgComponentFactories.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef ASG_TOOLS__ASG_COMPONENT_FACTORIES_H
#define ASG_TOOLS__ASG_COMPONENT_FACTORIES_H
 
#include <AsgMessaging/StatusCode.h>
#include <AsgTools/MessageCheckAsgTools.h>
#include <functional>
#include <memory>
 
namespace EL
{
  class AnaAlgorithm;
  class AnaReentrantAlgorithm;
  namespace Detail
  {
    class Module;
  }
}
 
namespace asg
{
  class AsgComponent;
  class AsgService;
  class AsgTool;
 
#ifdef XAOD_STANDALONE

  StatusCode registerComponentFactory (const std::string& type, const std::function<std::unique_ptr<AsgComponent>(const std::string& name)>& factory);

  const std::function<std::unique_ptr<AsgComponent>(const std::string& name)> *getComponentFactory (const std::string& type);
 

  template<typename T> StatusCode registerToolFactory (const std::string& type)
  {
    return registerComponentFactory (type, [] (const std::string& name) -> std::unique_ptr<AsgComponent> { return std::make_unique<T> (name); });
  }
  template<typename T> StatusCode registerServiceFactory (const std::string& type)
  {
    return registerComponentFactory (type, [] (const std::string& name) -> std::unique_ptr<AsgComponent> { return std::make_unique<T> (name, nullptr); });
  }
  template<typename T> StatusCode registerAlgorithmFactory (const std::string& type)
  {
    return registerComponentFactory (type, [] (const std::string& name) -> std::unique_ptr<AsgComponent> { return std::make_unique<T> (name, nullptr); });
  }
  template<typename T> StatusCode registerELModuleFactory (const std::string& type)
  {
    return registerComponentFactory (type, [] (const std::string& name) -> std::unique_ptr<AsgComponent> { return std::make_unique<T> (name); });
  }

  template<typename T> requires std::is_base_of_v<AsgTool,T>
  StatusCode registerGenericComponentFactory (const std::string& type)
  {
    return registerToolFactory<T> (type);
  }
  template<typename T> requires std::is_base_of_v<EL::AnaAlgorithm,T> || std::is_base_of_v<EL::AnaReentrantAlgorithm,T>
  StatusCode registerGenericComponentFactory (const std::string& type)
  {
    return registerAlgorithmFactory<T> (type);
  }
  template<typename T> requires std::is_base_of_v<AsgService,T>
  StatusCode registerGenericComponentFactory (const std::string& type)
  {
    return registerServiceFactory<T> (type);
  }
  template<typename T> requires std::is_base_of_v<EL::Detail::Module,T>
  StatusCode registerGenericComponentFactory (const std::string& type)
  {
    return registerELModuleFactory<T> (type);
  }

  template<typename T> class AutoRegisterComponentFactory final
  {
  public:
    AutoRegisterComponentFactory (const std::string& name)
    {
      using namespace asg::msgComponentConfig;
      if (!asg::registerGenericComponentFactory<T>(name).isSuccess())
      {
        ANA_MSG_FATAL("Failed to register component factory for " << name);
        std::terminate();
      } else
      {
        ANA_MSG_DEBUG("Registered component factory for " << name);
      }
    }
  };
  #define DECLARE_COMPONENT_JOIN(x,y) DECLARE_COMPONENT_JOIN2(x,y)
  #define DECLARE_COMPONENT_JOIN2(x,y) x ## y
  #define DECLARE_COMPONENT_IMP(TYPE) \
    namespace { \
      asg::AutoRegisterComponentFactory<TYPE> DECLARE_COMPONENT_JOIN(autoRegisterComponent,__LINE__) (#TYPE); \
    }
  #define DECLARE_COMPONENT(TYPE) DECLARE_COMPONENT_IMP(TYPE)

  std::vector<std::string> getLoadedComponentFactoryTypes ();

  void loadComponentFactoryModule (const std::string& moduleName, const std::string& modulePath = "");

  void loadComponentFactoryMap (const std::string& path);
 
#endif
}
 
#endif