Singleton module factory that creates EventProcessor objects. More...

#include <PluginFactory.h>

Classes
struct	PluginInfo
	info container to hold classname, class type and maker. More...

Public Member Functions
void	registerEventProcessor (const std::string &classname, int classtype, EventProcessorMaker *maker)
	Register the event processor.

void	registerConditionsObjectProvider (const std::string &classname, int classtype, ConditionsObjectProviderMaker *maker)
	Register a conditions object provider.

std::vector< std::string >	getEventProcessorClasses () const
	Get the classes associated with the processor.

int	getEventProcessorClasstype (const std::string &) const
	Get the class type for the event processor.

EventProcessor *	createEventProcessor (const std::string &classname, const std::string &moduleInstanceName, Process &process)
	Make an event processor.

ConditionsObjectProvider *	createConditionsObjectProvider (const std::string &classname, const std::string &objName, const std::string &tagname, const framework::config::Parameters &params, Process &process)
	Make a conditions object provider.

void	loadLibrary (const std::string &libname)
	Load a library.

Static Public Member Functions
static PluginFactory &	getInstance ()
	Get the factory instance.

Private Member Functions
	PluginFactory ()
	Constructor.

Private Attributes
std::map< std::string, PluginInfo >	moduleInfo_
	A map of names to processor containers.

std::set< std::string >	librariesLoaded_
	A set of names of loaded libraries.

Static Private Attributes
static PluginFactory	theFactory_
	Factory for creating the plugin objects.

Detailed Description

Singleton module factory that creates EventProcessor objects.

Definition at line 26 of file PluginFactory.h.

Constructor & Destructor Documentation

◆ PluginFactory()

framework::PluginFactory::PluginFactory ( )

private

Constructor.

Definition at line 12 of file PluginFactory.cxx.

12{}

Member Function Documentation

◆ createConditionsObjectProvider()

ConditionsObjectProvider * framework::PluginFactory::createConditionsObjectProvider	(	const std::string &	classname,
		const std::string &	objName,
		const std::string &	tagname,
		const framework::config::Parameters &	params,
		Process &	process
	)

Make a conditions object provider.

Parameters

classname	Class name of conditions object provider
objName	Name of the object provided (may be overriden internally!)
params	Parameters for the conditoons object provider
process	The process handle

Definition at line 76 of file PluginFactory.cxx.

                      {
  auto ptr = moduleInfo_.find(classname);
  if (ptr == moduleInfo_.end() || ptr->second.cop_maker == 0) {
    return 0;
  }
  return ptr->second.cop_maker(objName, tagname, params, process);
}

References moduleInfo_.

Referenced by framework::Conditions::createConditionsObjectProvider().

◆ createEventProcessor()

EventProcessor * framework::PluginFactory::createEventProcessor	(	const std::string &	classname,
		const std::string &	moduleInstanceName,
		Process &	process
	)

Make an event processor.

Parameters

classname	Class name of event processor.
moduleInstanceName	TODO.
process	The process handle

Definition at line 66 of file PluginFactory.cxx.

                      {
  auto ptr = moduleInfo_.find(classname);
  if (ptr == moduleInfo_.end() || ptr->second.ep_maker == 0) {
    return 0;
  }
  return ptr->second.ep_maker(moduleInstanceName, process);
}

References moduleInfo_.

Referenced by framework::Process::Process().

◆ getEventProcessorClasses()

std::vector< std::string > framework::PluginFactory::getEventProcessorClasses ( ) const

Get the classes associated with the processor.

Returns: a vector of strings corresponding to processor classes.

Definition at line 48 of file PluginFactory.cxx.

                                                                   {
  std::vector<std::string> classes;
  for (auto ptr : moduleInfo_) {
    if (ptr.second.ep_maker != 0) classes.push_back(ptr.first);
  }
  return classes;
}

References moduleInfo_.

◆ getEventProcessorClasstype()

int framework::PluginFactory::getEventProcessorClasstype ( const std::string & ct ) const

Get the class type for the event processor.

Parameters

TODO.

Definition at line 56 of file PluginFactory.cxx.

                                                                       {
  auto ptr = moduleInfo_.find(ct);
  if (ptr == moduleInfo_.end() || ptr->second.ep_maker == 0) {
    return 0;
 
  } else {
    return ptr->second.classtype;
  }
}

References moduleInfo_.

◆ getInstance()

static PluginFactory & framework::PluginFactory::getInstance ( )

inlinestatic

Get the factory instance.

Returns: The factory.

Definition at line 32 of file PluginFactory.h.

32{ return theFactory_; }

framework::PluginFactory::theFactory_

static PluginFactory theFactory_

Factory for creating the plugin objects.

Definition PluginFactory.h:119

References theFactory_.

Referenced by framework::Conditions::createConditionsObjectProvider(), framework::ConditionsObjectProvider::declare(), framework::EventProcessor::declare(), and framework::Process::Process().

◆ loadLibrary()

void framework::PluginFactory::loadLibrary ( const std::string & libname )

Load a library.

Parameters

libname The library to load.

Definition at line 87 of file PluginFactory.cxx.

                                                        {
  if (librariesLoaded_.find(libname) != librariesLoaded_.end()) {
    return;  // already loaded
  }
 
  void* handle = dlopen(libname.c_str(), RTLD_NOW);
  if (handle == nullptr) {
    EXCEPTION_RAISE("LibraryLoadFailure",
                    "Error loading library '" + libname + "':" + dlerror());
  }
 
  librariesLoaded_.insert(libname);
}

References librariesLoaded_.

◆ registerConditionsObjectProvider()

void framework::PluginFactory::registerConditionsObjectProvider	(	const std::string &	classname,
		int	classtype,
		ConditionsObjectProviderMaker *	maker
	)

Register a conditions object provider.

Parameters

classname	The name of the class associated with the conditions object provider.
classtype	The type of class associated with conditions object provider.
maker	TODO.

Definition at line 31 of file PluginFactory.cxx.

                                          {
  auto ptr = moduleInfo_.find(classname);
  if (ptr != moduleInfo_.end()) {
    EXCEPTION_RAISE("ExistingEventProcessorDefinition",
                    "Already have a module registered with the classname '" +
                        classname + "'");
  }
  PluginInfo mi;
  mi.classname = classname;
  mi.classtype = classtype;
  mi.cop_maker = maker;
  mi.ep_maker = 0;
  moduleInfo_[classname] = mi;
}

References moduleInfo_.

Referenced by framework::ConditionsObjectProvider::declare().

◆ registerEventProcessor()

void framework::PluginFactory::registerEventProcessor	(	const std::string &	classname,
		int	classtype,
		EventProcessorMaker *	maker
	)

Register the event processor.

Parameters

classname	The name of the class associated with processor.
classtype	The type of class associated with processor.
maker	TODO.

Definition at line 14 of file PluginFactory.cxx.

                                                                       {
  auto ptr = moduleInfo_.find(classname);
  if (ptr != moduleInfo_.end()) {
    EXCEPTION_RAISE("ExistingEventProcessorDefinition",
                    "Already have a module registered with the classname '" +
                        classname + "'");
  }
  PluginInfo mi;
  mi.classname = classname;
  mi.classtype = classtype;
  mi.ep_maker = maker;
  mi.cop_maker = 0;
  moduleInfo_[classname] = mi;
}

References moduleInfo_.

Referenced by framework::EventProcessor::declare().

Member Data Documentation

◆ librariesLoaded_

std::set<std::string> framework::PluginFactory::librariesLoaded_

private

A set of names of loaded libraries.

Definition at line 116 of file PluginFactory.h.

Referenced by loadLibrary().

◆ moduleInfo_

std::map<std::string, PluginInfo> framework::PluginFactory::moduleInfo_

private

A map of names to processor containers.

Definition at line 113 of file PluginFactory.h.

Referenced by createConditionsObjectProvider(), createEventProcessor(), getEventProcessorClasses(), getEventProcessorClasstype(), registerConditionsObjectProvider(), and registerEventProcessor().

◆ theFactory_

PluginFactory framework::PluginFactory::theFactory_

staticprivate

Factory for creating the plugin objects.

Definition at line 119 of file PluginFactory.h.

Referenced by getInstance().

The documentation for this class was generated from the following files:

Framework/include/Framework/PluginFactory.h
Framework/src/Framework/PluginFactory.cxx

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PluginFactory()

Member Function Documentation

◆ createConditionsObjectProvider()

◆ createEventProcessor()

◆ getEventProcessorClasses()

◆ getEventProcessorClasstype()

◆ getInstance()

◆ loadLibrary()

◆ registerConditionsObjectProvider()

◆ registerEventProcessor()

Member Data Documentation

◆ librariesLoaded_

◆ moduleInfo_

◆ theFactory_