PluginServiceDetailsV1.h

Go to the documentation of this file.

#ifndef _GAUDI_PLUGIN_SERVICE_DETAILS_V1_H_
#define _GAUDI_PLUGIN_SERVICE_DETAILS_V1_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 );
      }

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

#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 //_GAUDI_PLUGIN_SERVICE_DETAILS_H_