umbrello 2.39.2 Umbrello UML Modeller is a Unified Modelling Language (UML) diagram program based on KDE Technology

- Main Page
- Related Pages
- Topics
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Types | Public Member Functions | Static Public Member Functions | Private Slots | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
Umbrello::PluginLoader Class Reference
Umbrello2 API

`#include <pluginloader.h>`

Inheritance diagram for Umbrello::PluginLoader:

## Public Types
typedef Q3ValueList< Plugin * > | PluginList
typedef QMap< QString, Plugin * > | PluginMap
typedef QMap< QString, PluginList > | CategoryMap

## Public Member Functions
| ~PluginLoader ()
Plugin * | loadPlugin (const QString &name)
Plugin * | findPlugin (const QString &name)
void | unloadPlugin (const QString &name)
const PluginMap & | plugins () const
const CategoryMap & | categories () const

## Static Public Member Functions
static PluginLoader * | instance ()

## Private Slots
void | slotDestroyed (QObject *obj)

## Private Member Functions
| PluginLoader ()

## Private Attributes
PluginMap | _plugins
| The plugin mapping.
CategoryMap | _categories
| Categories of plugins.

## Static Private Attributes
static PluginLoader * | _instance = 0
| Singleton instance.

## Detailed Description

The plugin loader is an abstraction that sits on top of KLibLoader. Whereas plugins are specialized shared objects, the plugin must specialize the loading of those objects. Essentially, the plugin loader provides a single unit of functionality - loading plugins. In order to load a plugin, we must first load a shared library and then use the libraries factory to create the plugin. However, because a plugin is required to be a singleton, we must ensure that no plugin is ever created more than once. To that end, the loader must also retain a map of loaded plugins. When a loaded plugin is requested, we can increase its reference count.

On the subject of unloading, we actually have very little to do. The unload method on a plugin is simply a reference decrementer. When it reaches 0, the object destroys itself. Being a QObject, it will emit the destroyed signal just before deletion, allowing the plugin loader to respond to the event and remove the plugin from its mapping.

The PluginLoader also manages categories of plugins. The runtime categories actually reflect the directory structure of the build environment with each category represented by the name of a directory. The categories are "pre-seeded" at startup.

Bug
  Plugins are not removed from their respective categories when they are destroyed. It may be acceptable to call Plugin::category() from slotDestroyed because the category() method doesn't reference any local variables - it just returns a string.

## Member Typedef Documentation

## ◆ CategoryMap

typedef QMap<QString, PluginList> Umbrello::PluginLoader::CategoryMap

Container of plugin categories

## ◆ PluginList

typedef Q3ValueList<Plugin *> Umbrello::PluginLoader::PluginList

Just a container of plugins

## ◆ PluginMap

typedef QMap<QString, Plugin *> Umbrello::PluginLoader::PluginMap

The containment type for mapping plugins

## Constructor & Destructor Documentation

## ◆ ~PluginLoader()

PluginLoader::~PluginLoader | ( |  | ) |

Destroy the plugin loader

## ◆ PluginLoader()

PluginLoader::PluginLoader | ( |  | ) |
| private

Private constructor - This must be created through the instance method

## Member Function Documentation

## ◆ categories()

const PluginLoader::CategoryMap & PluginLoader::categories | ( |  | ) | const

Get a reference to the plugin category mapping.

## ◆ findPlugin()

Plugin * PluginLoader::findPlugin | ( | const QString & | name | ) |

Find a plugin

## ◆ instance()

PluginLoader * PluginLoader::instance | ( |  | ) |
| static

Singleton accessor

## ◆ loadPlugin()

Plugin * PluginLoader::loadPlugin | ( | const QString & | name | ) |

Load a plugin. Test to see if the plugin already exists. If it does, just add a reference to it and continue on.

## ◆ plugins()

const PluginLoader::PluginMap & PluginLoader::plugins | ( |  | ) | const

Get a reference to the plugin mapping. This method wraps everything in consts with the express purpose that no changes are made to the plugin map after using this method.

## ◆ slotDestroyed

void PluginLoader::slotDestroyed | ( | QObject * | obj | ) |
| private slot

This is used to connect to the destroyed signal emitted by plugins when they are finally deleted. The plugin loader uses this signal to remove the plugin from the plugin map.

## ◆ unloadPlugin()

void PluginLoader::unloadPlugin | ( | const QString & | name | ) |

Unload a plugin. Never use this method. It is only used by the deref method of a plugin to cause this class to unload the corresponding library. In fact, there is actually no corresponding plugin to unload, we just unload the library.

## Member Data Documentation

## ◆ _categories

CategoryMap Umbrello::PluginLoader::_categories
| private

Categories of plugins.

## ◆ _instance

PluginLoader * PluginLoader::_instance = 0
| static private

Singleton instance.

## ◆ _plugins

PluginMap Umbrello::PluginLoader::_plugins
| private

The plugin mapping.

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

- umbrello/_unused/pluginloader.h
- umbrello/_unused/pluginloader.cpp