#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 36 of file PluginFactoryBase.h.

Member Typedef Documentation

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

Definition at line 62 of file PluginFactoryBase.h.

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

Definition at line 61 of file PluginFactoryBase.h.

Constructor & Destructor Documentation

edmplugin::PluginFactoryBase::PluginFactoryBase ( )

inline

Definition at line 38 of file PluginFactoryBase.h.

References ~PluginFactoryBase().

38 {}

PluginFactoryBase::~PluginFactoryBase ( )

virtual

Definition at line 39 of file PluginFactoryBase.cc.

Referenced by PluginFactoryBase().

39 {}

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

privatedelete

Member Function Documentation

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.

References fillAvailable(), and m_plugins.

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

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().

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

private

Definition at line 129 of file PluginFactoryBase.cc.

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

Referenced by findPMaker(), and tryToFindPMaker().

                                                                                                         {
     //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.";
       }
     }
   }

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

protected

Definition at line 121 of file PluginFactoryBase.cc.

References fillInfo(), info(), m_plugins, and edmplugin::PluginInfo::name_.

Referenced by available().

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

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

protected

Definition at line 112 of file PluginFactoryBase.cc.

References edmplugin::PluginInfo::loadable_.

Referenced by fillAvailable().

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

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

protected

Definition at line 65 of file PluginFactoryBase.cc.

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().

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

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.

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

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

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

edmplugin::PluginFactoryManager::addFactory

void addFactory(const PluginFactoryBase *)

Definition: PluginFactoryManager.cc:55

edmplugin::PluginFactoryManager::get

static PluginFactoryManager * get()

Definition: PluginFactoryManager.cc:70

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

protected

Definition at line 58 of file PluginFactoryBase.cc.

References category(), info(), edmplugin::PluginInfo::loadable_, edmplugin::PluginManager::loadingFile(), edmplugin::PluginInfo::name_, newPluginAdded_, and callgraph::path.

Referenced by registerPMaker().

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

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

privatedelete

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

protected

Definition at line 145 of file PluginFactoryBase.cc.

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

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

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

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

protected

Definition at line 87 of file PluginFactoryBase.cc.

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().

                                                                        {
     //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;
   }

Member Data Documentation

Plugins edmplugin::PluginFactoryBase::m_plugins

private

Definition at line 109 of file PluginFactoryBase.h.

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

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 73 of file PluginFactoryBase.h.

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

Classes

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation