edmplugin::PluginFactoryBase Class Reference

#include <PluginFactoryBase.h>

Inheritance diagram for edmplugin::PluginFactoryBase:

Classes
struct	PluginMakerInfo

Public Types
typedef oneapi::tbb::concurrent_unordered_map< std::string, PMakers >	Plugins
typedef oneapi::tbb::concurrent_vector< PluginMakerInfo, edm::zero_allocator< 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...
const PluginFactoryBase &	operator= (const PluginFactoryBase &)=delete
	PluginFactoryBase ()
	PluginFactoryBase (const PluginFactoryBase &)=delete
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

Private Attributes
Plugins	m_plugins

Detailed Description

Definition at line 37 of file PluginFactoryBase.h.

Member Typedef Documentation

Plugins

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

Definition at line 65 of file PluginFactoryBase.h.

PMakers

typedef oneapi::tbb::concurrent_vector<PluginMakerInfo, edm::zero_allocator<PluginMakerInfo> > edmplugin::PluginFactoryBase::PMakers

Definition at line 64 of file PluginFactoryBase.h.

Constructor & Destructor Documentation

PluginFactoryBase() [1/2]

edmplugin::PluginFactoryBase::PluginFactoryBase ( )

inline

Definition at line 39 of file PluginFactoryBase.h.

{}

PluginFactoryBase() [2/2]

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

delete

~PluginFactoryBase()

PluginFactoryBase::~PluginFactoryBase ( )

virtual

Definition at line 40 of file PluginFactoryBase.cc.

{}

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 161 of file PluginFactoryBase.cc.

References fillAvailable(), and m_plugins.

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

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

fillAvailable()

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

protected

Definition at line 126 of file PluginFactoryBase.cc.

References fillInfo(), info(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and m_plugins.

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

fillInfo()

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

protected

Definition at line 117 of file PluginFactoryBase.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and 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);
    }
  }

findPMaker()

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

protected

Definition at line 66 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
            << "'";
      }
      //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) {
      }
    } 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);
  }

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 57 of file PluginFactoryBase.cc.

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

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

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

newPlugin()

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

protected

Definition at line 59 of file PluginFactoryBase.cc.

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

Referenced by registerPMaker().

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

operator=()

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

delete

registerPMaker()

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

protected

Definition at line 150 of file PluginFactoryBase.cc.

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

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

                                                                              {
    assert(nullptr != iPMaker);
    PMakers newMakers;
    newMakers.emplace_back(iPMaker, PluginManager::loadingFile());
    if (not m_plugins.emplace(iName, std::move(newMakers)).second) {
      //the item was already added
      m_plugins[iName].push_back(PluginMakerInfo(iPMaker, PluginManager::loadingFile()));
    }
    newPlugin(iName);
  }

tryToFindPMaker()

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

protected

Definition at line 92 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

m_plugins

Plugins edmplugin::PluginFactoryBase::m_plugins

private

Definition at line 109 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 77 of file PluginFactoryBase.h.

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