#include <NamedFactory.h>

Public Types
typedef IType	interface_type

typedef std::shared_ptr< IType >	interface_ptr

typedef WireCell::INamedFactory *	factory_ptr

typedef std::unordered_map< std::string, factory_ptr >	factory_lookup

typedef std::set< std::string >	known_type_set

Public Member Functions
	NamedFactoryRegistry ()

size_t	hello (const std::string &classname)

known_type_set	known_types () const

bool	associate (const std::string &classname, factory_ptr factory)
	Register an existing factory by the "class" name of the instance it can create. More...

factory_ptr	lookup_factory (const std::string &classname)
	Look up an existing factory by the name of the "class" it can create. More...

interface_ptr	instance (const std::string &classname, const std::string &instname="", bool create=true, bool nullok=false)

std::vector< std::string >	known_classes ()

Private Attributes
Log::logptr_t	l

factory_lookup	m_lookup

known_type_set	m_known_types

Detailed Description

template<class IType>
class WireCell::NamedFactoryRegistry< IType >

A registry of factories that produce instances which implement a given interface.

Definition at line 71 of file NamedFactory.h.

Member Typedef Documentation

template<class IType>

typedef std::unordered_map<std::string, factory_ptr> WireCell::NamedFactoryRegistry< IType >::factory_lookup

Definition at line 77 of file NamedFactory.h.

template<class IType>

typedef WireCell::INamedFactory* WireCell::NamedFactoryRegistry< IType >::factory_ptr

Definition at line 76 of file NamedFactory.h.

template<class IType>

typedef std::shared_ptr<IType> WireCell::NamedFactoryRegistry< IType >::interface_ptr

Definition at line 75 of file NamedFactory.h.

template<class IType>

typedef IType WireCell::NamedFactoryRegistry< IType >::interface_type

Definition at line 74 of file NamedFactory.h.

template<class IType>

typedef std::set<std::string> WireCell::NamedFactoryRegistry< IType >::known_type_set

Definition at line 78 of file NamedFactory.h.

Constructor & Destructor Documentation

template<class IType>

WireCell::NamedFactoryRegistry< IType >::NamedFactoryRegistry ( )

inline

Definition at line 80 of file NamedFactory.h.

80 : l(Log::logger("factory")) {}

WireCell::Log::logger

logptr_t logger(std::string name)

Definition: Logging.cxx:71

WireCell::NamedFactoryRegistry::l

Log::logptr_t l

Definition: NamedFactory.h:72

Member Function Documentation

template<class IType>

bool WireCell::NamedFactoryRegistry< IType >::associate	(	const std::string &	classname,
		factory_ptr	factory
	)

inline

Register an existing factory by the "class" name of the instance it can create.

Definition at line 88 of file NamedFactory.h.

                                                                         {
             m_lookup[classname] = factory;
             return true;
         }

template<class IType>

size_t WireCell::NamedFactoryRegistry< IType >::hello ( const std::string & classname )

inline

Definition at line 81 of file NamedFactory.h.

                                                  {
             m_known_types.insert(classname);
             return m_known_types.size();
         }

template<class IType>

interface_ptr WireCell::NamedFactoryRegistry< IType >::instance	(	const std::string &	classname,
		const std::string &	instname = `""`,
		bool	create = `true`,
		bool	nullok = `false`
	)

inline

Return instance of give type and optional instance name. If create is true, create the instance if it does not exist. If nullok is true return nullptr if it does not exist else throw by default.

Definition at line 141 of file NamedFactory.h.

                                                                       {
             factory_ptr fac = lookup_factory(classname);
             if (!fac) {
                 if (nullok) {
                     return nullptr;
                 }
                 l->error("no factory for class \"{}\" (instance \"{}\")", classname, instname);
                 std::cerr << "WireCell::NamedFactory: no factory for class \""
                           <<  classname << "\", (instance \"" << instname << "\"\n";
 
                 THROW(FactoryException() << errmsg{"No factory for class " + classname}); 
             }
             WireCell::Interface::pointer iptr;
             std::string action = "";
             if (create) {
                 iptr = fac->create(instname);
                 action = "create";
             }
             else {
                 iptr = fac->find(instname);
                 action = "find";
             }
             if (!iptr) {
                 if (nullok) {
                     return nullptr;
                 }
                 std::string msg = "NamedFactory: Failed to "+action+" instance \"" + instname;
                 msg += "\" of class \"" + classname + "\"";
                 l->error(msg);
                 THROW(FactoryException() << errmsg{msg}); 
             }
             interface_ptr uptype = std::dynamic_pointer_cast<interface_type>(iptr);
             if (!uptype) {
                 if (nullok) {
                     return nullptr;
                 }
                 std::string msg = "NamedFactory: Failed to cast instance: " + instname;
                 msg += " of class " + classname;
                 msg += " c++ type: " + type(iptr);
                 msg += " to " + type(uptype);
                 l->error(msg);
                 THROW(FactoryException() << errmsg{msg}); 
             }
             return uptype;
         }

template<class IType>

std::vector<std::string> WireCell::NamedFactoryRegistry< IType >::known_classes ( )

inline

Return a collection of class names known to this factory registry. Note: linked/plugged shared libraries do not automatically register their factories.

Definition at line 191 of file NamedFactory.h.

                                              {
             std::vector<std::string> ret;
             for (auto it : m_lookup) {
                 ret.push_back(it.first);
             }
             return ret;
         }

template<class IType>

known_type_set WireCell::NamedFactoryRegistry< IType >::known_types ( ) const

inline

Definition at line 85 of file NamedFactory.h.

85 { return m_known_types; }

WireCell::NamedFactoryRegistry::m_known_types

known_type_set m_known_types

Definition: NamedFactory.h:202

template<class IType>

factory_ptr WireCell::NamedFactoryRegistry< IType >::lookup_factory ( const std::string & classname )

inline

Look up an existing factory by the name of the "class" it can create.

Definition at line 95 of file NamedFactory.h.

                                                                {
             if (classname == "") {
                 l->error("no class name given for type \"{}\"",
                          demangle(typeid(IType).name()));
                 return nullptr;
             }
 
             auto it = m_lookup.find(classname);
             if (it != m_lookup.end()) {
                 return it->second;
             }
 
             // cache miss, try plugin
 
             WireCell::PluginManager& pm = WireCell::PluginManager::instance();
 
             std::string factory_maker = "make_" + classname + "_factory";
             auto plugin = pm.find(factory_maker.c_str());
             if (!plugin) {
                 l->error("no plugin for \"{}\"", classname);
                 return nullptr;
             }
 
             typedef void* (*maker_function)();
             maker_function mf;
             if (!plugin->symbol(factory_maker.c_str(), mf)) {
                 l->error("no factory maker symbol for \"{}\"", classname);
                 return nullptr;
             }
 
             void* fac_void_ptr = mf();
 
             if (!fac_void_ptr) {
                 l->error("no factory for \"{}\"", classname);
                 return nullptr;
             }
 
             factory_ptr fptr = reinterpret_cast<factory_ptr>(fac_void_ptr);
             m_lookup[classname] = fptr;
             return fptr;
         }