1 ////////////////////////////////////////////////////////////
\r
3 // Pluma - Plug-in Management Framework
\r
4 // Copyright (C) 2010-2012 Gil Costa (gsaurus@gmail.com)
\r
6 // This software is provided 'as-is', without any express or implied warranty.
\r
7 // In no event will the authors be held liable for any damages arising from the use of this software.
\r
9 // Permission is granted to anyone to use this software for any purpose,
\r
10 // including commercial applications, and to alter it and redistribute it freely,
\r
11 // subject to the following restrictions:
\r
13 // 1. The origin of this software must not be misrepresented;
\r
14 // you must not claim that you wrote the original software.
\r
15 // If you use this software in a product, an acknowledgment
\r
16 // in the product documentation would be appreciated but is not required.
\r
18 // 2. Altered source versions must be plainly marked as such,
\r
19 // and must not be misrepresented as being the original software.
\r
21 // 3. This notice may not be removed or altered from any source distribution.
\r
23 ////////////////////////////////////////////////////////////
\r
25 #ifndef PLUMA_PLUMA_HPP
\r
26 #define PLUMA_PLUMA_HPP
\r
28 ////////////////////////////////////////////////////////////
\r
30 ////////////////////////////////////////////////////////////
\r
31 #include <Pluma/Config.hpp>
\r
32 #include <Pluma/Provider.hpp>
\r
33 #include <Pluma/PluginManager.hpp>
\r
35 ////////////////////////////////////////////////////////////
\r
36 // Andy macro to convert parameter to string
\r
37 ////////////////////////////////////////////////////////////
\r
38 #define PLUMA_2STRING(X) #X
\r
40 ////////////////////////////////////////////////////////////
\r
41 // Macro that helps host applications defining
\r
42 // their provider classes
\r
43 ////////////////////////////////////////////////////////////
\r
44 #define PLUMA_PROVIDER_HEADER(TYPE)\
\r
45 PLUMA_PROVIDER_HEADER_BEGIN(TYPE)\
\r
46 virtual TYPE* create() const = 0;\
\r
47 PLUMA_PROVIDER_HEADER_END
\r
49 ////////////////////////////////////////////////////////////
\r
50 // Macro that generate first part of the provider definition
\r
51 ////////////////////////////////////////////////////////////
\r
52 #define PLUMA_PROVIDER_HEADER_BEGIN(TYPE)\
\r
53 class TYPE##Provider: public pluma::Provider{\
\r
55 friend class pluma::Pluma;\
\r
56 static const unsigned int PLUMA_INTERFACE_VERSION;\
\r
57 static const unsigned int PLUMA_INTERFACE_LOWEST_VERSION;\
\r
58 static const std::string PLUMA_PROVIDER_TYPE;\
\r
59 std::string plumaGetType() const{ return PLUMA_PROVIDER_TYPE; }\
\r
61 unsigned int getVersion() const{ return PLUMA_INTERFACE_VERSION; }
\r
63 ////////////////////////////////////////////////////////////
\r
64 // Macro that generate last part of the provider definition
\r
65 ////////////////////////////////////////////////////////////
\r
66 #define PLUMA_PROVIDER_HEADER_END };
\r
68 ////////////////////////////////////////////////////////////
\r
69 // Macro that generate the provider declaration
\r
70 ////////////////////////////////////////////////////////////
\r
71 #define PLUMA_PROVIDER_SOURCE(TYPE, Version, LowestVersion)\
\r
72 const std::string TYPE##Provider::PLUMA_PROVIDER_TYPE = PLUMA_2STRING( TYPE );\
\r
73 const unsigned int TYPE##Provider::PLUMA_INTERFACE_VERSION = Version;\
\r
74 const unsigned int TYPE##Provider::PLUMA_INTERFACE_LOWEST_VERSION = LowestVersion;
\r
77 ////////////////////////////////////////////////////////////
\r
78 // Macro that helps plugins generating their provider implementations
\r
79 // PRE: SPECIALIZED_TYPE must inherit from BASE_TYPE
\r
80 ////////////////////////////////////////////////////////////
\r
81 #define PLUMA_INHERIT_PROVIDER(SPECIALIZED_TYPE, BASE_TYPE)\
\r
82 class SPECIALIZED_TYPE##Provider: public BASE_TYPE##Provider{\
\r
84 BASE_TYPE * create() const{ return new SPECIALIZED_TYPE (); }\
\r
90 ////////////////////////////////////////////////////////////
\r
91 /// \brief Pluma plugins management
\r
93 ////////////////////////////////////////////////////////////
\r
94 class Pluma: public PluginManager{
\r
97 ////////////////////////////////////////////////////////////
\r
98 /// \brief Default Constructor
\r
100 ////////////////////////////////////////////////////////////
\r
103 ////////////////////////////////////////////////////////////
\r
104 /// \brief Tell Pluma to accept a certain type of providers
\r
106 /// A Pluma object is able to accept multiple types of providers.
\r
107 /// When a plugin is loaded, it tries to register it's providers
\r
108 /// implementations. Those are only accepted by the host
\r
109 /// application if it's accepting providers of that kind.
\r
111 /// \tparam ProviderType type of provider.
\r
113 ////////////////////////////////////////////////////////////
\r
114 template<typename ProviderType>
\r
115 void acceptProviderType();
\r
117 ////////////////////////////////////////////////////////////
\r
118 /// \brief Get the stored providers of a certain type.
\r
120 /// Providers are added at the end of the \a providers vector.
\r
122 /// \tparam ProviderType type of provider to be returned.
\r
123 /// \param[out] providers Vector to fill with the existing
\r
126 ////////////////////////////////////////////////////////////
\r
127 template<typename ProviderType>
\r
128 void getProviders(std::vector<ProviderType*>& providers);
\r
131 #include <Pluma/Pluma.inl>
\r
136 #endif // PLUMA_PLUMA_HPP
\r
139 ////////////////////////////////////////////////////////////
\r
140 /// \class pluma::Pluma
\r
142 /// Pluma is the main class of Pluma library. Allows hosting
\r
143 /// applications to load/unload dlls in runtime (plugins), and
\r
144 /// to get providers of shared interface objects.
\r
148 /// pluma::Pluma pluma;
\r
149 /// // Tell it to accept providers of the type DeviceProvider
\r
150 /// pluma.acceptProviderType<DeviceProvider>();
\r
151 /// // Load some dll
\r
152 /// pluma.load("plugins/standard_devices");
\r
153 /// // Get device providers into a vector
\r
154 /// std::vector<DeviceProvider*> providers;
\r
155 /// pluma.getProviders(providers);
\r
156 /// // create a Device from the first provider
\r
157 /// if (!providers.empty()){
\r
158 /// Device* myDevice = providers.first()->create();
\r
159 /// // do something with myDevice
\r
160 /// std::cout << device->getDescription() << std::endl;
\r
162 /// delete myDevice;
\r
166 /// It is also possible to add local providers, providers that
\r
167 /// are defined directly on the host application. That can
\r
168 /// be useful to provide and use default implementations of certain
\r
169 /// interfaces, along with plugin implementations.
\r
171 ////////////////////////////////////////////////////////////
\r