pluma::Provider Class Reference

Interface to provide applications with objects from plugins. More...

#include <Provider.hpp>

List of all members.

Public Member Functions
virtual	~Provider ()
	Destructor.
virtual unsigned int	getVersion () const =0
	Get provider version.
bool	isCompatible (const Host &host) const
	Check compatibility with host.
Friends
class	Host

---

Detailed Description

Interface to provide applications with objects from plugins.

The plugin specific implementations are unknown at the host side, only their shared interfaces are known. Then, host app needs a generic way of create interface objects. That's what provider classes are for. It is the factory design pattern (http://www.oodesign.com/factory-pattern.html)

Shared interfaces define their provider types (by inheriting from pluma::Provider). Hosts then use those tipes to get objects from the plugins. Plugins derive the shared interface providers so that they can provide host with specific implementations of the shared interface. Those specific providers are given to the host through a connect function.

Example: A host app uses objects of type Device. A certain plugin defines a Keyboard, witch is a Device. The Host will use DeviceProviders to create objects of type Device. The plugin will provide host specifically with a KeyboardProvider. Other plugins may provide host with other derived DeviceProvider types.

Device hpp (shared):

 #include <Pluma/Pluma.hpp>
 class Device{
 public:
     virtual std::string getDescription() const = 0;
 };
 // create DevicedProvider class
 PLUMA_PROVIDER_HEADER(Device);

Device cpp (shared):

 #include "Device.hpp"
 generate DevicedProvider with version 6, and compatible with at least v.3
 PLUMA_PROVIDER_SOURCE(Device, 6, 3);

Keyboard code on the plugin side:

 #include <Pluma/Pluma.hpp>
 #include "Device.hpp"

 class Keyboard: public Device{
 public:
     std::string getDescription() const{
         return "keyboard";
     }
 };

 // create KeyboardProvider, it implements DeviceProvider
 PLUMA_INHERIT_PROVIDER(Keyboard, Device);

plugin connector:

 #include <Pluma/Connector.hpp>
 #include "Keyboard.hpp"

 PLUMA_CONNECTOR
 bool connect(pluma::Host& host){
     // add a keyboard provider to host
     host.add( new KeyboardProvider() );
     return true;
 }

Host application code:

 #include <Pluma/Pluma.hpp>

 #include "Device.hpp"
 #include <iostream>
 #include <vector>

 int main(){

     pluma::Pluma plugins;
     // Tell plugins manager to accept providers of the type DeviceProvider
     plugins.acceptProviderType<DeviceProvider>();
     // Load library "standard_devices" from folder "plugins"
     plugins.load("plugins", "standard_devices");

     // Get device providers into a vector
     std::vector<DeviceProvider*> providers;
     plugins.getProviders(providers);

     // create a Device from the first provider
     if (!providers.empty()){
         Device* myDevice = providers.first()->create();
         // do something with myDevice
         std::cout << device->getDescription() << std::endl;
         // and delete it in the end
         delete myDevice;
     }
     return 0;
 }

Definition at line 42 of file Provider.hpp.

---

Constructor & Destructor Documentation

virtual pluma::Provider::~Provider

(

)

[virtual]

Destructor.

---

Member Function Documentation

virtual unsigned int pluma::Provider::getVersion

(

)

const [pure virtual]

Get provider version.

Returns:

Version number.

bool pluma::Provider::isCompatible

(

const Host &

host

)

const

Check compatibility with host.

The same provider may be compiled with different versions on host side and on plugins side. This function checks if a plugin provider is compatible with the current version of the same provider type on the host side.

Parameters:

host	Host, proxy of host application.

Returns:

True if it's compatible with host.

---

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

• Provider.hpp