#include <NodeLoader.h>

Collaboration diagram for CPN::NodeLoader:

Public Member Functions
	NodeLoader ()

	~NodeLoader ()

void	LoadSharedLib (const std::string &libname)

void	LoadSharedLib (const std::vector< std::string > &list)

void	LoadNodeList (const std::string &filename)

void	LoadNodeList (const std::vector< std::string > &list)

void	SearchDirectory (const std::string &dirname)

void	SearchDirectory (const std::vector< std::string > &dirnames)

NodeFactory *	GetFactory (const std::string &nodename)

void	RegisterFactory (shared_ptr< NodeFactory > factory)

Private Types
typedef std::map< std::string, lt__handle * >	LibMap

typedef std::map< std::string, shared_ptr< NodeFactory > >	FactoryMap

typedef std::map< std::string, std::string >	NodeLibMap

Private Member Functions
void	InternalLoadLib (const std::string &lib)

void	InternalLoad (const std::string &sym)

Private Attributes
LibMap	libmap

FactoryMap	factorymap

NodeLibMap	nodelibmap

Detailed Description

This class encapsulates the necessary data and functions for loading up nodes.

Definition at line 45 of file NodeLoader.h.

Member Typedef Documentation

typedef std::map<std::string, shared_ptr<NodeFactory> > CPN::NodeLoader::FactoryMap

private

Definition at line 90 of file NodeLoader.h.

typedef std::map<std::string, lt__handle*> CPN::NodeLoader::LibMap

private

Definition at line 88 of file NodeLoader.h.

typedef std::map<std::string, std::string> CPN::NodeLoader::NodeLibMap

private

Definition at line 92 of file NodeLoader.h.

Constructor & Destructor Documentation

CPN::NodeLoader::NodeLoader ( )

Definition at line 40 of file NodeLoader.cc.

                            {
         PthreadMutexProtected al(lock);
         if (lt_dlinit() > 0) {
             throw std::runtime_error(lt_dlerror());
         }
     }

CPN::NodeLoader::~NodeLoader ( )

Definition at line 47 of file NodeLoader.cc.

References factorymap, and libmap.

                             {
         PthreadMutexProtected al(lock);
         factorymap.clear();
         for (LibMap::iterator itr = libmap.begin(); itr != libmap.end(); ++itr) {
             lt_dlclose(itr->second);
         }
         libmap.clear();
         lt_dlexit();
     }

Member Function Documentation

NodeFactory * CPN::NodeLoader::GetFactory ( const std::string & nodename )

Get the NodeFactory for the given node type

Parameters

nodename the node type

Returns: a node factory

Definition at line 99 of file NodeLoader.cc.

References ASSERT, factorymap, and InternalLoad().

                                                                  {
         PthreadMutexProtected al(lock);
         FactoryMap::iterator entry = factorymap.find(nodetype);
         if (entry == factorymap.end()) {
             InternalLoad(nodetype);
             entry = factorymap.find(nodetype);
             ASSERT(entry != factorymap.end());
         }
         return entry->second.get();
     }

Here is the call graph for this function:

void CPN::NodeLoader::InternalLoad ( const std::string & sym )

private

Definition at line 144 of file NodeLoader.cc.

References CPN_DEFAULT_INIT_SYMBOL_STR, factorymap, InternalLoadLib(), and nodelibmap.

Referenced by GetFactory().

                                                        {
         std::string sym = CPN_DEFAULT_INIT_SYMBOL_STR;
         sym += name;
         lt_dlhandle handle = 0;
 
         // Use a union to avoid having to cast
         // from void pointer to function pointer explicitely.
         // Doing so would violate strict aliasing.
         union {
             void *vptr;
             CPNInitPrototype fn;
         } init;
 
         handle = lt_dlopen(0);
         if (!handle) {
             throw std::runtime_error(lt_dlerror());
         }
         try {
             lt_dlerror();
             init.vptr = lt_dlsym(handle, sym.c_str());
             const char *error = lt_dlerror();
             if (error != 0) {
                 NodeLibMap::iterator itr = nodelibmap.find(sym);
                 if (itr == nodelibmap.end()) {
                     throw std::runtime_error("Unable to find node type " + name);
                 }
                 InternalLoadLib(itr->second);
                 lt_dlerror();
                 init.vptr = lt_dlsym(handle, sym.c_str());
                 error = lt_dlerror();
                 if (error != 0) {
                     throw std::runtime_error(error);
                 }
             }
             shared_ptr<NodeFactory> factory = init.fn();
             factorymap.insert(std::make_pair(factory->GetName(), factory));
         } catch (...) {
             lt_dlclose(handle);
             throw;
         }
         lt_dlclose(handle);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::NodeLoader::InternalLoadLib ( const std::string & lib )

private

Definition at line 116 of file NodeLoader.cc.

References libmap.

Referenced by InternalLoad(), and LoadSharedLib().

                                                          {
         if (libmap.find(lib) == libmap.end()) {
             struct advise_t {
                 advise_t() {
                     if (lt_dladvise_init(&advise) > 0) {
                         throw std::runtime_error(lt_dlerror());
                     }
                 }
                 ~advise_t() {
                     lt_dladvise_destroy(&advise);
                 }
                 void global() {
                     if (lt_dladvise_global(&advise) > 0) {
                         throw std::runtime_error(lt_dlerror());
                     }
                 }
                 lt_dladvise advise;
             } advise;
             advise.global();
             lt_dlhandle handle = lt_dlopenadvise(lib.c_str(), advise.advise);
             if (!handle) {
                 throw std::runtime_error(lt_dlerror());
             } else {
                 libmap.insert(std::make_pair(lib, handle));
             }
         }
     }

Here is the caller graph for this function:

void CPN::NodeLoader::LoadNodeList ( const std::string & filename )

Loads up a node list. A node list contains information about what shared libraries need to be loaded to get a given node.

Parameters

filename the name of the nodelist file.

Definition at line 68 of file NodeLoader.cc.

References Loader(), and nodelibmap.

Referenced by CPN::Kernel::Kernel(), LoadNodeList(), and SearchDirectory().

                                                            {
         Loader(filename, nodelibmap);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::NodeLoader::LoadNodeList ( const std::vector< std::string > & list )

Definition at line 72 of file NodeLoader.cc.

References LoadNodeList().

                                                                   {
         for (std::vector<std::string>::const_iterator i = list.begin(), e = list.end(); i != e; ++i) {
             LoadNodeList(*i);
         }
     }

Here is the call graph for this function:

void CPN::NodeLoader::LoadSharedLib ( const std::string & libname )

Loads a shared library for node init function searching.

Parameters

libname the shared library file name

Definition at line 57 of file NodeLoader.cc.

References InternalLoadLib().

Referenced by CPN::Kernel::Kernel(), and LoadSharedLib().

                                                            {
         PthreadMutexProtected al(lock);
         InternalLoadLib(libname);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::NodeLoader::LoadSharedLib ( const std::vector< std::string > & list )

Definition at line 62 of file NodeLoader.cc.

References LoadSharedLib().

                                                                    {
         for (std::vector<std::string>::const_iterator i = list.begin(), e = list.end(); i != e; ++i) {
             LoadSharedLib(*i);
         }
     }

Here is the call graph for this function:

void CPN::NodeLoader::RegisterFactory ( shared_ptr< NodeFactory > factory )

Manually register a node factory with the NodeLoader.

Parameters

factory the factory

Definition at line 110 of file NodeLoader.cc.

References factorymap.

                                                                     {
         PthreadMutexProtected al(lock);
         std::string name = factory->GetName();
         factorymap.insert(std::make_pair(name, factory));
     }

void CPN::NodeLoader::SearchDirectory ( const std::string & dirname )

Search a directory for .nodelist files to add to the node lists

Parameters

dirname the directory to search

Definition at line 78 of file NodeLoader.cc.

References Directory::End(), and LoadNodeList().

Referenced by CPN::Kernel::Kernel(), and SearchDirectory().

                                                              {
         std::string ext = ".nodelist";
         for (Directory dir(dirname); !dir.End(); dir.Next()) {
             if (dir.IsRegularFile()) {
                 std::string fname = dir.BaseName();
                 if (fname[0] == '.') { continue; }
                 if (fname.size() < ext.size()
                         || fname.substr(fname.size() - ext.size(), ext.size()) != ext) {
                     continue;
                 }
                 LoadNodeList(dir.FullName());
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::NodeLoader::SearchDirectory ( const std::vector< std::string > & dirnames )

Definition at line 93 of file NodeLoader.cc.

References SearchDirectory().

                                                                          {
         for (std::vector<std::string>::const_iterator i = dirnames.begin(), e = dirnames.end(); i != e; ++i) {
             SearchDirectory(*i);
         }
     }