PluginServiceDetailsV1.h

Go to the documentation of this file.

#ifndef GAUDIPLUGINSERVICE_GAUDI_DETAILS_PLUGINSERVICEDETAILSV1_H
#define GAUDIPLUGINSERVICE_GAUDI_DETAILS_PLUGINSERVICEDETAILSV1_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"
 
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <utility>
 
#include <mutex>
 
namespace Gaudi {
  namespace PluginService {
    GAUDI_PLUGIN_SERVICE_V1_INLINE namespace v1 {
      namespace Details {
        template <class T>
        class Factory {
        public:
          template <typename S, typename... Args>
          static typename S::ReturnType create( Args&&... args ) {
            return new T( std::forward<Args>( args )... );
          }
        };
 
        GAUDIPS_API
        void* getCreator( const std::string& id, const std::string& type );
 
        template <typename F>
        inline F getCreator( const std::string& id ) {
          union {
            void* src;
            F     dst;
          } p2p;
          p2p.src = getCreator( id, typeid( F ).name() );
          return p2p.dst;
        }
 
        GAUDIPS_API
        std::string demangle( const std::type_info& id );
 
        template <typename T>
        inline std::string demangle() {
          return demangle( typeid( T ) );
        }
 
        class GAUDIPS_API Registry {
        public:
          typedef std::string KeyType;
 
          typedef std::map<KeyType, std::string> Properties;
 
          struct FactoryInfo {
            FactoryInfo( std::string lib, void* p = nullptr, std::string t = "", std::string rt = "",
                         std::string cn = "", Properties props = Properties() )
                : library( std::move( lib ) )
                , ptr( p )
                , type( std::move( t ) )
                , rtype( std::move( rt ) )
                , className( std::move( cn ) )
                , properties( std::move( props ) ) {}
 
            std::string library;
            void*       ptr;
            std::string type;
            std::string rtype;
            std::string className;
            Properties  properties;
 
            FactoryInfo& addProperty( const KeyType& k, std::string v ) {
              properties[k] = std::move( v );
              return *this;
            }
          };
 
          typedef std::map<KeyType, FactoryInfo> FactoryMap;
 
          static Registry& instance();
 
          template <typename F, typename T, typename I>
          inline FactoryInfo& add( const I& id, typename F::FuncType ptr ) {
            union {
              typename F::FuncType src;
              void*                dst;
            } p2p;
            p2p.src = ptr;
            std::ostringstream o;
            o << id;
            return add( o.str(), p2p.dst, typeid( typename F::FuncType ).name(),
                        typeid( typename F::ReturnType ).name(), demangle<T>() );
          }
 
          void* get( const std::string& id, const std::string& type ) const;
 
          const FactoryInfo& getInfo( const std::string& id ) const;
 
          Registry& addProperty( const std::string& id, const std::string& k, const std::string& v );
 
          std::set<KeyType> loadedFactoryNames() const;
 
          inline const FactoryMap& factories() const {
            if ( !m_initialized ) const_cast<Registry*>( this )->initialize();
            return m_factories;
          }
 
        private:
          Registry();
 
          Registry( const Registry& ) : m_initialized( false ) {}
 
          FactoryInfo& add( const std::string& id, void* factory, const std::string& type, const std::string& rtype,
                            const std::string& className, const Properties& props = Properties() );
 
          inline FactoryMap& factories() {
            if ( !m_initialized ) initialize();
            return m_factories;
          }
 
          void initialize();
 
          bool m_initialized;
 
          FactoryMap m_factories;
 
          mutable std::recursive_mutex m_mutex;
        };
 
        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 );
      } // namespace Details
 
      GAUDIPS_API void SetDebug( int debugLevel );
      GAUDIPS_API int Debug();
    }
  } // namespace PluginService
} // namespace Gaudi
 
#define _PS_V1_INTERNAL_FACTORY_REGISTER_CNAME( name, serial ) _register_##_##serial
 
#define _PS_V1_INTERNAL_DECLARE_FACTORY_WITH_CREATOR( type, typecreator, id, factory, serial )                         \
  namespace {                                                                                                          \
    class _PS_V1_INTERNAL_FACTORY_REGISTER_CNAME( type, serial ) {                                                     \
    public:                                                                                                            \
      typedef factory      s_t;                                                                                        \
      typedef typecreator  f_t;                                                                                        \
      static s_t::FuncType creator() { return &f_t::create<s_t>; }                                                     \
      _PS_V1_INTERNAL_FACTORY_REGISTER_CNAME( type, serial )() {                                                       \
        using ::Gaudi::PluginService::v1::Details::Registry;                                                           \
        Registry::instance().add<s_t, type>( id, creator() );                                                          \
      }                                                                                                                \
    } _PS_V1_INTERNAL_FACTORY_REGISTER_CNAME( s_##type, serial );                                                      \
  }
 
#define _PS_V1_INTERNAL_DECLARE_FACTORY( type, id, factory, serial )                                                   \
  _PS_V1_INTERNAL_DECLARE_FACTORY_WITH_CREATOR( type, ::Gaudi::PluginService::v1::Details::Factory<type>, id, factory, \
                                                serial )
 
#endif // GAUDIPLUGINSERVICE_GAUDI_DETAILS_PLUGINSERVICEDETAILSV1_H