PluginServiceDetails.h

Go to the documentation of this file.

#ifndef _GAUDI_PLUGIN_SERVICE_DETAILS_H_
#define _GAUDI_PLUGIN_SERVICE_DETAILS_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 <map>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <utility>

#if defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L
#include <mutex>
#endif

#if __GNUC__ >= 4
#define GAUDIPS_HASCLASSVISIBILITY
#endif

#if defined( GAUDIPS_HASCLASSVISIBILITY )
#define GAUDIPS_IMPORT __attribute__( ( visibility( "default" ) ) )
#define GAUDIPS_EXPORT __attribute__( ( visibility( "default" ) ) )
#define GAUDIPS_LOCAL __attribute__( ( visibility( "hidden" ) ) )
#else
#define GAUDIPS_IMPORT
#define GAUDIPS_EXPORT
#define GAUDIPS_LOCAL
#endif

#ifdef GaudiPluginService_EXPORTS
#define GAUDIPS_API GAUDIPS_EXPORT
#else
#define GAUDIPS_API GAUDIPS_IMPORT
#endif

namespace Gaudi
{
  namespace PluginService
  {

    namespace Details
    {
      template <class T>
      class Factory
      {
      public:
#if !defined( __REFLEX__ ) || defined( ATLAS )
        template <typename S, typename... Args>
        static typename S::ReturnType create( Args&&... args )
        {
          return new T( std::forward<Args>( args )... );
        }
#endif
      };

      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 = 0, 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> loadedFactories() 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;

#if defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L
        mutable std::recursive_mutex m_mutex;
#endif
      };

      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 );
    }

    GAUDIPS_API void SetDebug( int debugLevel );
    GAUDIPS_API int Debug();
  }
}

#define _INTERNAL_FACTORY_REGISTER_CNAME( name, serial ) _register_##_##serial

#define _INTERNAL_DECLARE_FACTORY_WITH_CREATOR( type, typecreator, id, factory, serial )                               \
  namespace                                                                                                            \
  {                                                                                                                    \
    class _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>; }                                                     \
      _INTERNAL_FACTORY_REGISTER_CNAME( type, serial )()                                                               \
      {                                                                                                                \
        using ::Gaudi::PluginService::Details::Registry;                                                               \
        Registry::instance().add<s_t, type>( id, creator() );                                                          \
      }                                                                                                                \
    } _INTERNAL_FACTORY_REGISTER_CNAME( s_##type, serial );                                                            \
  }

#define _INTERNAL_DECLARE_FACTORY( type, id, factory, serial )                                                         \
  _INTERNAL_DECLARE_FACTORY_WITH_CREATOR( type, ::Gaudi::PluginService::Details::Factory<type>, id, factory, serial )

#endif //_GAUDI_PLUGIN_SERVICE_DETAILS_H_