robowflex::IO::PluginManager Class Reference

A singleton class for dynamic loading classes through pluginlib. More...

#include <plugin.h>

Public Member Functions
	PluginManager (PluginManager const &)=delete
void	operator= (PluginManager const &)=delete
template<typename T >
std::shared_ptr< T >	loadPlugin (const std::string &package, const std::string &plugin)
	Load a plugin named plugin of type T. More...

Static Public Member Functions
static PluginManager &	getInstance ()
	Get the singleton instance of PluginManager. More...
template<typename T >
static std::shared_ptr< T >	load (const std::string &package, const std::string &plugin)
	Load a plugin named plugin of type T using the singleton instance. More...

Private Types
template<typename T >
using	Loader = pluginlib::ClassLoader< T >
	A typed class loader. More...
template<typename T >
using	LoaderPtr = std::shared_ptr< Loader< T > >
	A shared pointer to a typed class loader. More...
using	BaseLoader = pluginlib::ClassLoaderBase
	The base class of the class loader. More...
using	BaseLoaderPtr = std::shared_ptr< BaseLoader >
	A shared pointer to the base class of the class loader. More...

Private Member Functions
	PluginManager ()
	Constructor. More...
template<typename T >
LoaderPtr< T >	getLoader (const std::string &package)
	Gets the plugin loader for a plugin type T. Grabs the loader from cached loaders if available, otherwise creates the plugin loader and caches it. More...

Private Attributes
std::mutex	mutex_
	Class loading mutex. More...
std::map< std::pair< std::string, std::string >, BaseLoaderPtr >	loaders_
	Cached loaders. More...

Detailed Description

A singleton class for dynamic loading classes through pluginlib.

Definition at line 23 of file plugin.h.

Member Typedef Documentation

BaseLoader

using robowflex::IO::PluginManager::BaseLoader = pluginlib::ClassLoaderBase

private

The base class of the class loader.

Definition at line 95 of file plugin.h.

BaseLoaderPtr

using robowflex::IO::PluginManager::BaseLoaderPtr = std::shared_ptr<BaseLoader>

private

A shared pointer to the base class of the class loader.

Definition at line 99 of file plugin.h.

Loader

template<typename T >

using robowflex::IO::PluginManager::Loader = pluginlib::ClassLoader<T>

private

A typed class loader.

Template Parameters

T	The type of class to load via the plugin loader.

Definition at line 85 of file plugin.h.

LoaderPtr

template<typename T >

using robowflex::IO::PluginManager::LoaderPtr = std::shared_ptr<Loader<T> >

private

A shared pointer to a typed class loader.

Template Parameters

T	The type of class to load via the plugin loader.

Definition at line 91 of file plugin.h.

Constructor & Destructor Documentation

PluginManager() [1/2]

robowflex::IO::PluginManager::PluginManager ( PluginManager const &  )

delete

PluginManager() [2/2]

robowflex::IO::PluginManager::PluginManager ( )

inlineprivate

Constructor.

Definition at line 103 of file plugin.h.

            {
            }

Member Function Documentation

getInstance()

static PluginManager& robowflex::IO::PluginManager::getInstance ( )

inlinestatic

Get the singleton instance of PluginManager.

Returns

The singleton PluginManager.

Definition at line 33 of file plugin.h.

            {
                static PluginManager instance;
                return instance;
            }

getLoader()

template<typename T >

LoaderPtr<T> robowflex::IO::PluginManager::getLoader ( const std::string &  package )

inlineprivate

Gets the plugin loader for a plugin type T. Grabs the loader from cached loaders if available, otherwise creates the plugin loader and caches it.

Parameters

[in]

package

ROS package that exports class T.

Template Parameters

T	The type of plugin loader to get.

Returns

A plugin loader that loads plugins of type T.

Definition at line 115 of file plugin.h.

            {
                std::unique_lock<std::mutex> lock(mutex_);
 
                // Need to possibly demangle type name...
                const std::string &type = ROBOWFLEX_DEMANGLE(typeid(T).name());
                auto key = std::make_pair(package, type);
 
                LoaderPtr<T> loader;
 
                auto cached = loaders_.find(key);
                if (cached != loaders_.end())
                    loader = std::dynamic_pointer_cast<Loader<T>>(cached->second);
                else
                {
                    RBX_INFO("Creating Class Loader for type `%s` from package `%s`!", type, package);
 
                    loader.reset(new pluginlib::ClassLoader<T>(package, type));
                    loaders_[key] = std::static_pointer_cast<BaseLoader>(loader);
                }
 
                return loader;
            }

load()

template<typename T >

static std::shared_ptr<T> robowflex::IO::PluginManager::load ( const std::string &  package, const std::string &  plugin  )

inlinestatic

Load a plugin named plugin of type T using the singleton instance.

Parameters

[in]	package	ROS package that exports plugin's base class T.
[in]	plugin	Name of the plugin to load.

Template Parameters

T	The type of the plugin to load.

Returns

A shared pointer to the loaded plugin on success, nullptr on failure.

Definition at line 46 of file plugin.h.

            {
                return getInstance().loadPlugin<T>(package, plugin);
            }

loadPlugin()

template<typename T >

std::shared_ptr<T> robowflex::IO::PluginManager::loadPlugin ( const std::string &  package, const std::string &  plugin  )

inline

Load a plugin named plugin of type T.

Parameters

[in]	package	ROS package that exports plugin's base class T.
[in]	plugin	Name of the plugin to load.

Template Parameters

T	The type of the plugin to load.

Returns

A shared pointer to the loaded plugin on success, nullptr on failure.

Definition at line 58 of file plugin.h.

            {
                if (ros::package::getPath(package).empty())
                {
                    RBX_ERROR("Package `%s` does not exist.", package);
                    return nullptr;
                }
 
                auto loader = getLoader<T>(package);
 
                try
                {
                    std::shared_ptr<T> loaded(loader->createUnmanagedInstance(plugin));
                    return loaded;
                }
                catch (pluginlib::LibraryLoadException &e)
                {
                    RBX_ERROR("Failed to library: %s", e.what());
                    return nullptr;
                }
            }

operator=()

void robowflex::IO::PluginManager::operator= ( PluginManager const &  )

delete

Member Data Documentation

loaders_

std::map<std::pair<std::string, std::string>, BaseLoaderPtr> robowflex::IO::PluginManager::loaders_

private

Cached loaders.

Definition at line 140 of file plugin.h.

mutex_

std::mutex robowflex::IO::PluginManager::mutex_

private

Class loading mutex.

Definition at line 139 of file plugin.h.

---

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

• plugin.h