C++ / CMake : Making a plugin system for many 'source plugins' - c++

Question

I am working on a C++ library consisting of many plugins, which can be included independently of each other. The set of plugins is only dependent on the users requirements at compile time.
The plugins are source code only, they are not standalone binaries.
For this purpose, the main (and only) CMakeLists.txt of the library has a predefined plugins list, and every plugin found in a plugins directory is added to the binary target.
In addition, a preprocessor #define with the name of the plugin is set:
set (plugins
plugin1
plugin2
plugin3
...)
#optional plugins
foreach(library ${plugins})
file(TO_CMAKE_PATH "plugins/${library}" librarypath)
get_filename_component(librarypath ${librarypath} ABSOLUTE)
if(EXISTS ${librarypath})
message("--> found ${library}")
include_directories(${librarypath}/include)
file(GLOB libsources "${librarypath}/src/*.cpp" "${librarypath}/src/*.f90")
set(sources ${sources} ${libsources})
string(TOUPPER ${library} LIBRARY)
add_definitions(-D${LIBRARY})
endif()
endforeach(library)
Now in my main library, what I basically do is the following:
#ifdef PLUGIN1
# include "plugin1.h"
#endif
#ifdef PLUGIN2
# include "plugin2.h"
#endif
#ifdef PLUGIN3
# include "plugin3.h"
#endif
...
// each plugin has a unique id:
enum PluginID : int {
Plugin1 = 1,
Plugin2 = 2,
Plugin3 = 3,
};
// the name of each plugin is associated with its ID,
PluginID getPluginIDFromName( const std::string& PluginName )
{
static std::map<std::string, PluginID> PluginIDMap = {
{"PLUGIN1", Plugin1},
{"PLUGIN2", Plugin2},
{"PLUGIN3", Plugin3},
};
return PluginIDMap[PluginName];
}
// Load a plugin by its ID
PluginBaseClass* pluginFactory( PluginID pluginID)
{
switch ( pluginID ) {
#ifdef PLUGIN1
case Plugin1: { return new class Plugin1();}
#endif
#ifdef PLUGIN2
case Plugin2: { return new class Plugin2();}
#endif
#ifdef PLUGIN3
case Plugin3: { return new class Plugin3();}
#endif
}}
So the result is that in the main source I can load the plugin via:
PluginBaseClass* thePlugin1 = pluginFactory ( getPluginIDFromName ("PLUGIN1") );
Everything works as intended, but I feel that what I do is some kind of abusing cmake and preprocessor macros. Is there any better way to achieve my goals?
In addition, manually updating the map and switch for each possible plugin is rather cumbersome.
The requirement I have is that the user should not need to modify CMakeLists.txt manually. Thank you in advance!
Edit: I want to make the plugins available both via their IDs or their names, hence the two functions. In addition, static linking is preferred; I see no reason for dynamic loading.

Answer 1

Instead of manually creating the mapping from id to plugin name and the factory function by hand you can use what is known as "self-registration" and have the compiler do most of the work for you.
A static plugin factory
First, we need a factory class where the individual plugins can register themselves. The declaration might look something like this:
class PluginFactory
{
public:
using PluginCreationFunctionT = PluginBaseClass(*)();
PluginFactory() = delete;
static bool Register(std::string_view plugin name,
PluginID id,
PluginCreationFunctionT creation_function);
static PluginBaseClass* Create(std::string_view name);
static PluginBaseClass* Create(PluginID id);
private:
static std::map<std::string_view, PluginCreationFunctionT> s_CreationFunctionByName;
static std::map<PluginID, PluginCreationFunctionT> s_CreationFunctionById;
};
The corresponding source file then contains
std::map<std::string_view, PluginFactory::PluginCreationFunctionT>
PluginFactory::s_CreationFunctionByName;
std::map<PluginID, PluginFactory::PluginCreationFunctionT>
PluginFactory::s_CreationFunctionById;
bool PluginFactory::Register(std::string_view const plugin name,
PluginId const id,
PluginCreationFunctionT const creation_function)
{
// assert that no two plugins accidentally try to register
// with the same name or id
assert(s_CreationFunctionByName.find(name) == s_CreationFunctionByName.end());
assert(s_CreationFunctionById.find(id) == s_CreationFunctionById.end());
s_CreateFunctionByName.insert(name, creation_function);
s_CreateFunctionById.insert(id, creation_function);
return true;
}
PluginBaseClass* PluginFactory::Create(std::string_view const name)
{
auto const it = s_CreationFunctionByName.find(name);
return it != s_CreationFunctionByName.end() ? it->second() : nullptr;
}
PluginBaseClass* PluginFactory::Create(std::string_view const id)
{
auto const it = s_CreationFunctionById.find(name);
return it != s_CreationFunctionById.end() ? it->second() : nullptr;
}
Note that Register always returns true - we'll need it to return a value in order to use the Register function as an initializer for a global variable. Being an initializer of a global variable causes the compiler to emit code to call the Register function during program startup.
In your main function you can now obtain an instance of a particular plugin via
PluginBaseClass* thePlugin1 = PluginFactory::Create("PLUGIN1");
or via
PluginBaseClass* thePlugin1 = PluginFactory::Create(PluginID::Plugin1);
Modifying the plugins
The plugins themselves now need to be modified so that they register themselves. In theory any global variable would to, but to avoid name clashes between different plugins it is easiest to just add a static data member to each plugin class, e.g.
class Plugin1 : public PluginBaseClass {
public:
...
private:
static bool s_IsRegistered;
};
and then add the following to the source file for the plugin:
namespace {
PluginBaseClass* create_plugin1()
{
return new Plugin1{};
}
}
bool Plugin1::s_IsRegistered
= PluginFactory::Register("PLUGIN1", PluginID::Plugin1, create_plugin1);
Simplifying the CMake code
Now that the compiler generates the mapping you no longer need the preprocessor definitions. All that your CMake-code now needs to do is add the correct include directories and sources. But that doesn't need to be part of the main CMake file. Instead, you can put a CMakeLists.txt into each of the plugin folders and then include them either via add_subdirectory or include into the main CMakefile:
foreach(library ${plugins})
if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/plugins/${library}/CMakeLists.txt)
message(STATUS "--> found ${library}"
include(${CMAKE_CURRENT_LIST_DIR}/plugins/${library}/CMakeLists.txt)
else()
message(FATAL "Unknown plugin ${library} requested!")
endif()
endforeach()
The CMakeLists.txt for plugin1 in the plugins/plugin1 folder then contains just
include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
file(GLOB sources_plugin1 "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/*.f90")
list(APPEND sources ${sources_plugin1})
It might not look like much of an improvement in this particular case, but having these separate CMakeLists.txt files now also allows conditionally adding dependencies.
For example, assume that Plugin2 is the only plugin that uses boost. With the separate CMakeLists.txt you can add everything you need to find and use boost to the CMakeLists.txt of Plugin2 without polluting the main CMakeLists.txt file.

Answer 2

read plugin list from external file. read here. Basically move
set (plugins
plugin1
plugin2
plugin3
...)
into plugins.cmake file, and use
include(plugins.cmake) in your main cmake file.
In order to avoid the need to manually modify the map and switch: if it is OK to assume e.g. max number of plugins is 64, you may use bit masks in the following manner:
auto plugin_mask = PLUGINS;
auto id = 1;
while (plugin_mask)
{
if (plugin_mask & 1)
{
// found plugin
// add to map
std::pair<std::string, PluginID> p;
p.first = "PLUGIN" + std::to_string(id);
p.second = static_cast<PluginID>(id++);
PluginIDMap.insert(p);
} plugin_mask >> 1;
}