PluginServiceDetailsV2.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 2013-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef _GAUDI_PLUGIN_SERVICE_DETAILS_V2_H_
#define _GAUDI_PLUGIN_SERVICE_DETAILS_V2_H_
 
 
#include <Gaudi/Details/PluginServiceCommon.h>
 
#include <any>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <utility>
 
namespace Gaudi {
  namespace PluginService {
    GAUDI_PLUGIN_SERVICE_V2_INLINE namespace v2 {
      template <typename>
      struct Factory;
 
      namespace Details {
        template <typename>
        struct Traits;
 
        template <typename R, typename... Args>
        struct Traits<R( Args... )> {
          using ReturnType  = std::unique_ptr<std::remove_pointer_t<R>>;
          using FactoryType = std::function<ReturnType( Args... )>;
        };
 
        GAUDIPS_API
        std::string demangle( const std::type_info& id );
 
        template <typename T>
        inline std::string demangle() {
          return demangle( typeid( T ) );
        }
 
        template <typename ID>
        inline std::string stringify_id( const ID& id ) {
          std::ostringstream o;
          o << id;
          return o.str();
        }
        template <>
        inline std::string stringify_id<std::string>( const std::string& id ) {
          return id;
        }
 
        void reportBadAnyCast( const std::type_info& factory_type, const std::string& id );
 
        class GAUDIPS_API Logger {
        public:
          enum Level { Debug = 0, Info = 1, Warning = 2, Error = 3 };
          Logger( Level level = Warning ) : m_level( level ) {}
          virtual ~Logger() {}
          inline Level level() const { return m_level; }
          inline void  setLevel( Level level ) { m_level = level; }
          inline void  info( const std::string& msg ) { report( Info, msg ); }
          inline void  debug( const std::string& msg ) { report( Debug, msg ); }
          inline void  warning( const std::string& msg ) { report( Warning, msg ); }
          inline void  error( const std::string& msg ) { report( Error, msg ); }
 
        private:
          virtual void report( Level lvl, const std::string& msg );
          Level        m_level;
        };
 
        GAUDIPS_API Logger& logger();
        GAUDIPS_API void setLogger( Logger* logger );
 
        class GAUDIPS_API Registry {
        public:
          using KeyType = std::string;
 
          using Properties = std::map<KeyType, std::string>;
 
          struct FactoryInfo {
            std::string library;
            std::any    factory{};
            Properties  properties{};
 
            inline bool             is_set() const { return factory.has_value(); }
            Properties::mapped_type getprop( const Properties::key_type& name ) const;
          };
 
          using FactoryMap = std::map<KeyType, FactoryInfo>;
 
          template <typename F>
          F get( const KeyType& id ) {
            const FactoryInfo& info = Registry::instance().getInfo( id, true );
 
            // Check if factory has been marked as deprecated.
            const auto& prop = info.properties.find( "deprecated" );
            if ( prop != info.properties.end() ) {
              std::string msg = "factory '" + info.getprop( "ClassName" ) + "' is deprecated" +
                                ( prop->second.empty() ? "" : ( ": " + prop->second ) );
              if ( m_werror.find( "deprecated" ) != m_werror.end() ) {
                logger().error( msg );
                return std::any_cast<F>( std::any() );
              } else {
                logger().warning( msg );
              }
            }
 
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
            if ( !info.getprop( "ReflexName" ).empty() ) {
              const std::string real_name = info.getprop( "ClassName" );
              logger().warning( "requesting factory via old name '" + id + "' use '" +
                                ( real_name.empty() ? "<undefined>" : real_name ) + "' instead" );
            }
#endif
            return std::any_cast<F>( info.factory );
          }
 
          static Registry& instance();
 
          FactoryInfo& add( const KeyType& id, FactoryInfo info );
 
          FactoryMap::size_type erase( const KeyType& id );
 
          const FactoryInfo& getInfo( const KeyType& id, const bool load = false ) const;
 
          Registry& addProperty( const KeyType& id, const KeyType& k, const std::string& v );
 
          void setError( const KeyType& warning );
 
          void unsetError( const KeyType& warning );
 
          std::set<KeyType> loadedFactoryNames() const;
 
          const FactoryMap& factories() const;
 
        private:
          Registry();
 
          Registry( const Registry& ) = delete;
 
          FactoryMap& factories();
 
          void initialize();
 
          mutable std::once_flag m_initialized;
 
          FactoryMap m_factories;
 
          std::set<KeyType> m_werror;
 
          mutable std::recursive_mutex m_mutex;
        };
 
        template <typename, typename>
        struct DefaultFactory;
        template <typename T, typename R, typename... Args>
        struct DefaultFactory<T, Factory<R( Args... )>> {
          inline typename Factory<R( Args... )>::ReturnType operator()( Args... args ) {
            return std::make_unique<T>( std::move( args )... );
          }
        };
 
        std::string getDSONameFor( void* fptr );
      } // namespace Details
 
      GAUDIPS_API void SetDebug( int debugLevel );
      GAUDIPS_API int Debug();
    }
  } // namespace PluginService
} // namespace Gaudi
 
#define _PS_V2_INTERNAL_FACTORY_MAKE_REGISTER_CNAME_TOKEN( serial ) _register_##serial
#define _PS_V2_INTERNAL_FACTORY_MAKE_REGISTER_CNAME( serial )                                                          \
  _PS_V2_INTERNAL_FACTORY_MAKE_REGISTER_CNAME_TOKEN( serial )
#define _PS_V2_INTERNAL_FACTORY_REGISTER_CNAME _PS_V2_INTERNAL_FACTORY_MAKE_REGISTER_CNAME( __LINE__ )
 
#endif //_GAUDI_PLUGIN_SERVICE_DETAILS_H_