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 <string>
#include <sstream>
#include <map>
#include <set>
#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_