edmplugin::PluginFactoryBase Class Reference

#include <PluginFactoryBase.h>

Inheritance diagram for edmplugin::PluginFactoryBase:

Classes
struct	PluginMakerInfo

Public Types
typedef tbb::concurrent_unordered_map< std::string, PMakers >	Plugins
typedef tbb::concurrent_vector< PluginMakerInfo >	PMakers

Public Member Functions
virtual std::vector< PluginInfo >	available () const
	return info about all plugins which are already available in the program More...
virtual const std::string &	category () const =0
	returns the name of the category to which this plugin factory belongs More...
	PluginFactoryBase ()
virtual	~PluginFactoryBase ()

Public Attributes
edm::signalslot::Signal< void(const std::string &, const PluginInfo &)>	newPluginAdded_
	signal containing plugin category, and plugin info for newly added plugin More...

Protected Member Functions
void	fillAvailable (std::vector< PluginInfo > &iReturn) const
void	fillInfo (const PMakers &makers, PluginInfo &iInfo, std::vector< PluginInfo > &iReturn) const
void *	findPMaker (const std::string &iName) const
void	finishedConstruction ()
void	newPlugin (const std::string &iName)
void	registerPMaker (void *iPMaker, const std::string &iName)
void *	tryToFindPMaker (const std::string &iName) const

Private Member Functions
void	checkProperLoadable (const std::string &iName, const std::string &iLoadedFrom) const
const PluginFactoryBase &	operator= (const PluginFactoryBase &)=delete
	PluginFactoryBase (const PluginFactoryBase &)=delete

Private Attributes
Plugins	m_plugins

Detailed Description

Definition at line 37 of file PluginFactoryBase.h.

Member Typedef Documentation

Plugins

typedef tbb::concurrent_unordered_map<std::string, PMakers> edmplugin::PluginFactoryBase::Plugins

Definition at line 63 of file PluginFactoryBase.h.

PMakers

typedef tbb::concurrent_vector<PluginMakerInfo> edmplugin::PluginFactoryBase::PMakers

Definition at line 62 of file PluginFactoryBase.h.

Constructor & Destructor Documentation

PluginFactoryBase() [1/2]

edmplugin::PluginFactoryBase::PluginFactoryBase ( )

inline

Definition at line 39 of file PluginFactoryBase.h.

{}

~PluginFactoryBase()

PluginFactoryBase::~PluginFactoryBase ( )

virtual

Definition at line 39 of file PluginFactoryBase.cc.

{}

PluginFactoryBase() [2/2]

edmplugin::PluginFactoryBase::PluginFactoryBase ( const PluginFactoryBase &  )

privatedelete

Member Function Documentation

available()

std::vector< PluginInfo > PluginFactoryBase::available ( ) const

virtual

return info about all plugins which are already available in the program

Reimplemented in edmplugin::PluginCapabilities.

Definition at line 151 of file PluginFactoryBase.cc.

                                                           {
    std::vector<PluginInfo> returnValue;
    returnValue.reserve(m_plugins.size());
    fillAvailable(returnValue);
    return returnValue;
  }

References fillAvailable(), and m_plugins.

category()

virtual const std::string& edmplugin::PluginFactoryBase::category ( ) const

pure virtual

returns the name of the category to which this plugin factory belongs

Implemented in edmplugin::PluginFactory< R *(Args...)>, and edmplugin::PluginCapabilities.

Referenced by checkProperLoadable(), findPMaker(), newPlugin(), and tryToFindPMaker().

checkProperLoadable()

void PluginFactoryBase::checkProperLoadable ( const std::string &  iName, const std::string &  iLoadedFrom  ) const

private

Definition at line 129 of file PluginFactoryBase.cc.

                                                                                                        {
    //should check to see if this is from the proper loadable if it
    // was not statically linked
    if (iLoadedFrom != PluginManager::staticallyLinkedLoadingFileName() && PluginManager::isAvailable()) {
      if (iLoadedFrom != PluginManager::get()->loadableFor(category(), iName).string()) {
        throw cms::Exception("WrongPluginLoaded")
            << "The plugin '" << iName << "' should have been loaded from\n '"
            << PluginManager::get()->loadableFor(category(), iName).string()
            << "'\n but instead it was already loaded from\n '" << iLoadedFrom
            << "'\n because some other plugin was loaded from the latter loadables.\n"
               "To work around the problem the plugin '"
            << iName << "' should only be defined in one of these loadables.";
      }
    }
  }

References category(), Exception, edmplugin::PluginManager::get(), edmplugin::PluginManager::isAvailable(), edmplugin::PluginManager::loadableFor(), and edmplugin::PluginManager::staticallyLinkedLoadingFileName().

Referenced by findPMaker(), and tryToFindPMaker().

fillAvailable()

void PluginFactoryBase::fillAvailable ( std::vector< PluginInfo > &  iReturn ) const

protected

Definition at line 121 of file PluginFactoryBase.cc.

                                                                            {
    PluginInfo info;
    for (Plugins::const_iterator it = m_plugins.begin(); it != m_plugins.end(); ++it) {
      info.name_ = it->first;
      fillInfo(it->second, info, iReturn);
    }
  }

References fillInfo(), info(), and m_plugins.

Referenced by available().

fillInfo()

void PluginFactoryBase::fillInfo ( const PMakers &  makers, PluginInfo &  iInfo, std::vector< PluginInfo > &  iReturn  ) const

protected

Definition at line 112 of file PluginFactoryBase.cc.

                                                                                                                 {
    for (PMakers::const_iterator it = makers.begin(); it != makers.end(); ++it) {
      while (nullptr == it->m_ptr.load(std::memory_order_acquire))
        ;
      iInfo.loadable_ = it->m_name;
      iReturn.push_back(iInfo);
    }
  }

References edmplugin::PluginInfo::loadable_.

Referenced by fillAvailable().

findPMaker()

void * PluginFactoryBase::findPMaker ( const std::string &  iName ) const

protected

Definition at line 65 of file PluginFactoryBase.cc.

                                                                  {
    //do we already have it?
    Plugins::const_iterator itFound = m_plugins.find(iName);
    if (itFound == m_plugins.end()) {
      std::string lib = PluginManager::get()->load(this->category(), iName).path().string();
      itFound = m_plugins.find(iName);
      if (itFound == m_plugins.end()) {
        throw cms::Exception("PluginCacheError")
            << "The plugin '" << iName << "' should have been in loadable\n '" << lib
            << "'\n but was not there.  This means the plugin cache is incorrect.  Please run 'EdmPluginRefresh " << lib
            << "'";
      }
    } else {
      //The item in the container can still be under construction so wait until the m_ptr has been set since that is done last
      auto const& value = itFound->second.front();
      while (value.m_ptr.load(std::memory_order_acquire) == nullptr) {
      }
      checkProperLoadable(iName, value.m_name);
    }
    return itFound->second.front().m_ptr.load(std::memory_order_acquire);
  }

References category(), checkProperLoadable(), Exception, edmplugin::PluginManager::get(), mps_check::lib, edmplugin::PluginManager::load(), m_plugins, edmplugin::SharedLibrary::path(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmplugin::PluginFactory< R *(Args...)>::create().

finishedConstruction()

void PluginFactoryBase::finishedConstruction ( )

protected

call this as the last line in the constructor of inheriting classes this is done so that the virtual table will be properly initialized when the routine is called

Definition at line 56 of file PluginFactoryBase.cc.

{ PluginFactoryManager::get()->addFactory(this); }

References edmplugin::PluginFactoryManager::addFactory(), and edmplugin::PluginFactoryManager::get().

Referenced by edmplugin::PluginCapabilities::PluginCapabilities().

newPlugin()

void PluginFactoryBase::newPlugin ( const std::string &  iName )

protected

Definition at line 58 of file PluginFactoryBase.cc.

                                                          {
    PluginInfo info;
    info.loadable_ = boost::filesystem::path(PluginManager::loadingFile());
    info.name_ = iName;
    newPluginAdded_(category(), info);
  }

References category(), info(), edmplugin::PluginManager::loadingFile(), newPluginAdded_, and castor_dqm_sourceclient_file_cfg::path.

Referenced by registerPMaker().

operator=()

const PluginFactoryBase& edmplugin::PluginFactoryBase::operator= ( const PluginFactoryBase &  )

privatedelete

registerPMaker()

void PluginFactoryBase::registerPMaker ( void *  iPMaker, const std::string &  iName  )

protected

Definition at line 145 of file PluginFactoryBase.cc.

                                                                              {
    assert(nullptr != iPMaker);
    m_plugins[iName].push_back(PluginMakerInfo(iPMaker, PluginManager::loadingFile()));
    newPlugin(iName);
  }

References cms::cuda::assert(), edmplugin::PluginManager::loadingFile(), m_plugins, and newPlugin().

Referenced by edmplugin::PluginFactory< R *(Args...)>::registerPMaker().

tryToFindPMaker()

void * PluginFactoryBase::tryToFindPMaker ( const std::string &  iName ) const

protected

Definition at line 87 of file PluginFactoryBase.cc.

                                                                       {
    //do we already have it?
    Plugins::const_iterator itFound = m_plugins.find(iName);
    if (itFound == m_plugins.end()) {
      const SharedLibrary* slib = PluginManager::get()->tryToLoad(this->category(), iName);
      if (nullptr != slib) {
        std::string lib = slib->path().string();
        itFound = m_plugins.find(iName);
        if (itFound == m_plugins.end()) {
          throw cms::Exception("PluginCacheError")
              << "The plugin '" << iName << "' should have been in loadable\n '" << lib
              << "'\n but was not there.  This means the plugin cache is incorrect.  Please run 'EdmPluginRefresh "
              << lib << "'";
        }
      }
    } else {
      //The item in the container can still be under construction so wait until the m_ptr has been set since that is done last
      auto const& value = itFound->second.front();
      while (value.m_ptr.load(std::memory_order_acquire) == nullptr) {
      }
      checkProperLoadable(iName, value.m_name);
    }
    return itFound != m_plugins.end() ? itFound->second.front().m_ptr.load(std::memory_order_acquire) : nullptr;
  }

References category(), checkProperLoadable(), Exception, edmplugin::PluginManager::get(), mps_check::lib, m_plugins, edmplugin::SharedLibrary::path(), AlCaHLTBitMon_QueryRunRegistry::string, and edmplugin::PluginManager::tryToLoad().

Referenced by edmplugin::PluginFactory< R *(Args...)>::tryToCreate().

Member Data Documentation

m_plugins

Plugins edmplugin::PluginFactoryBase::m_plugins

private

Definition at line 111 of file PluginFactoryBase.h.

Referenced by available(), fillAvailable(), findPMaker(), registerPMaker(), and tryToFindPMaker().

newPluginAdded_

edm::signalslot::Signal<void(const std::string&, const PluginInfo&)> edmplugin::PluginFactoryBase::newPluginAdded_

mutable

signal containing plugin category, and plugin info for newly added plugin

Definition at line 75 of file PluginFactoryBase.h.

Referenced by newPlugin(), and edmplugin::PluginCapabilities::tryToFind().