pluma::Provider Class Reference

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

#include <Provider.hpp>

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

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

pluma::Provider::~Provider ( )

virtual

Destructor.

Definition at line 36 of file Provider.cpp.

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.

Definition at line 42 of file Provider.cpp.

---

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

• Provider.hpp
• Provider.cpp