PluginFactoryBase.h

Go to the documentation of this file.

#ifndef FWCore_PluginManager_PluginFactoryBase_h
#define FWCore_PluginManager_PluginFactoryBase_h
// -*- C++ -*-
//
// Package:     PluginManager
// Class  :     PluginFactoryBase
//
//
// Original Author:  Chris Jones
//         Created:  Wed Apr  4 12:24:44 EDT 2007
//
 
// system include files
#include <string>
#include <vector>
#include <map>
#include <atomic>
#include "tbb/concurrent_unordered_map.h"
#include "tbb/concurrent_vector.h"
 
#include "FWCore/Utilities/interface/Signal.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"
// user include files
#include "FWCore/PluginManager/interface/PluginInfo.h"
 
// forward declarations
namespace edmplugin {
  class PluginFactoryBase {
  public:
    PluginFactoryBase() {}
    PluginFactoryBase(const PluginFactoryBase&) = delete;                   // stop default
    const PluginFactoryBase& operator=(const PluginFactoryBase&) = delete;  // stop default
    virtual ~PluginFactoryBase();
 
    struct PluginMakerInfo {
      PluginMakerInfo(void* iPtr, const std::string& iName) : m_name(iName), m_ptr() {
        m_ptr.store(iPtr, std::memory_order_release);
      }
 
      PluginMakerInfo(const PluginMakerInfo& iOther) : m_name(iOther.m_name), m_ptr() {
        m_ptr.store(iOther.m_ptr.load(std::memory_order_acquire), std::memory_order_release);
      }
 
      PluginMakerInfo& operator=(const PluginMakerInfo& iOther) {
        m_name = iOther.m_name;
        m_ptr.store(iOther.m_ptr.load(std::memory_order_acquire), std::memory_order_release);
        return *this;
      }
      std::string m_name;
      //NOTE: this has to be last since once it is non zero it signals
      // that the construction has finished
      std::atomic<void*> m_ptr;
    };
 
    typedef tbb::concurrent_vector<PluginMakerInfo> PMakers;
    typedef tbb::concurrent_unordered_map<std::string, PMakers> Plugins;
 
    // ---------- const member functions ---------------------
 
    virtual std::vector<PluginInfo> available() const;
 
    virtual const std::string& category() const = 0;
 
    //The signal is only modified during a shared library load which is protected by a mutex by the operating system
    CMS_THREAD_SAFE mutable edm::signalslot::Signal<void(const std::string&, const PluginInfo&)> newPluginAdded_;
 
    // ---------- static member functions --------------------
 
    // ---------- member functions ---------------------------
 
  protected:
    void finishedConstruction();
 
    void newPlugin(const std::string& iName);
 
    //since each inheriting class has its own Container type to hold their PMakers
    // this function allows them to share the same code when doing the lookup
    // this routine will throw an exception if iName is unknown therefore the return value is always valid
    void* findPMaker(const std::string& iName) const;
 
    //similar to findPMaker but will return 'end()' if iName is known
    void* tryToFindPMaker(const std::string& iName) const;
 
    void fillInfo(const PMakers& makers, PluginInfo& iInfo, std::vector<PluginInfo>& iReturn) const;
 
    void fillAvailable(std::vector<PluginInfo>& iReturn) const;
 
    void registerPMaker(void* iPMaker, const std::string& iName);
 
  private:
    void checkProperLoadable(const std::string& iName, const std::string& iLoadedFrom) const;
    // ---------- member data --------------------------------
    Plugins m_plugins;
  };
 
}  // namespace edmplugin
#endif