PluginServiceDetailsV2.h

Go to the documentation of this file.

#ifndef _GAUDI_PLUGIN_SERVICE_DETAILS_V2_H_
#define _GAUDI_PLUGIN_SERVICE_DETAILS_V2_H_
/*****************************************************************************\
* (c) Copyright 2013 CERN                                                     *
*                                                                             *
* This software is distributed under the terms of the GNU General Public      *
* Licence version 3 (GPL Version 3), copied verbatim in the file "LICENCE".   *
*                                                                             *
* 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.                                       *
\*****************************************************************************/


#include "Gaudi/Details/PluginServiceCommon.h"

#if __cplusplus >= 201703
#  include <any>
#else
#  include <boost/any.hpp>
namespace std {
  using boost::any;
  using boost::any_cast;
  using boost::bad_any_cast;
} // namespace std
#endif

#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 {
#if __cplusplus >= 201703
              return factory.has_value();
#else
              return !factory.empty();
#endif
            }
            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 );
#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 );

          const FactoryInfo& getInfo( const KeyType& id, const bool load = false ) const;

          Registry& addProperty( const KeyType& id, const KeyType& k, const std::string& v );

          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;

          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_