refactore

* Refactored api
* Adding badge
* Remove #prama once
* Change clangformat settings
* Added threading primitive wrappers
* Updated Docs
* Extended tests / added tests for parallel access
* Cache and store factories itself
* Added iterators

Author: DerThorsten

.clang-format

@@ -1,4 +1,5 @@
 ---
 BasedOnStyle: Microsoft
 AlwaysBreakTemplateDeclarations: 'Yes'
+PackConstructorInitializers: 'Never'
 ...

.github/workflows/ci.yaml

@@ -114,7 +114,7 @@ jobs:
           cache-environment: true
           post-cleanup: 'all'
 
-      - name: build and test
+      - name: build
         shell: cmd /C CALL {0}
         run: |
           mkdir bld
@@ -126,9 +126,13 @@ jobs:
            -DXPLUGIN_BUILD_EXAMPLES=OFF ^
            -DCMAKE_PREFIX_PATH="%CONDA_PREFIX%\Library" ^
            -DCMAKE_INSTALL_PREFIX="%CONDA_PREFIX%
-
           cmake --build . --config Release
-          ctest -C Release -V
+
+      - name: Run C++ tests
+        shell: cmd /C CALL {0}
+        run: |
+          cd bld
+          ctest -V --config Release
 
       - name: Install
         shell: cmd /C CALL {0}

README.md

@@ -99,12 +99,10 @@ int main(int argc, char** argv)
     std::string plugin_directory = argv[1];
 
 
-    plugin_registry_type registry;
-    registry.add_from_directory(plugin_directory);
+    plugin_registry_type registry(plugin_directory);
 
-    for (auto& name : registry.plugin_names()){
+    for (auto [name, factory] : registry){
         std::cout << name << std::endl;
-        auto factory = registry.create_factory(name);
         auto plugin = factory->create();
         plugin->do_something();
     }
@@ -215,15 +213,13 @@ int main(int argc, char** argv)
     std::string plugin_directory = argv[1];
 
 
-    plugin_registry_type registry;
-    registry.add_from_directory(plugin_directory);
+    plugin_registry_type registry(plugin_directory);
 
     int some_data = 42;
     std::string some_other_data = "Hello World";
 
-    for (auto& name : registry.plugin_names()){
+    for (auto [name, factory] : registry){
         std::cout << name << std::endl;
-        auto factory = registry.create_factory(name);
         auto plugin = factory->create(some_data, some_other_data);
         plugin->do_something();
     }

cmake/xplugin_emscripten_utils.cmake

@@ -10,6 +10,9 @@ endfunction()
 function(xplugin_add_emscripten_flags)
     if(EMSCRIPTEN)
         set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE)
+        #  for emscripten we do not want any threads or thread primitives
+        add_compile_definitions(XPLUGIN_NO_THREADS)
+
         set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-s SIDE_MODULE=1")
         set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-s SIDE_MODULE=1")
         set(CMAKE_STRIP FALSE)

docs/api/index.rst

@@ -6,16 +6,23 @@ C++ API
 Models
 --------
 
-
-
 .. doxygenclass:: xp::xshared_library
    :project: xplugin
 
+.. doxygenclass:: xp::xlazy_shared_library_plugin_factory
+   :project: xplugin
+
 .. doxygenclass:: xp::xfactory_base
    :project: xplugin
 
 .. doxygenclass:: xp::xfactory
    :project: xplugin
 
-.. doxygenclass:: xp::xplugin_registry
+.. doxygenclass:: xp::detail::xplugin_registry_impl
+   :project: xplugin
+
+.. doxygentypedef:: xp::xplugin_registry
+   :project: xplugin
+
+.. doxygentypedef:: xp::xthread_save_plugin_registry
    :project: xplugin

examples/accumulator/main_accumulator.cpp

@@ -18,27 +18,24 @@ int main(int argc, char **argv)
     using factory_base_type = xp::xfactory_base<base_type>;
     using plugin_registry_type = xp::xplugin_registry<factory_base_type>;
 
-    plugin_registry_type registry;
-    registry.add_from_directory(plugin_directory);
+    plugin_registry_type registry(plugin_directory);
 
     std::cout << "available plugins:" << std::endl;
-    for (auto &p : registry.plugin_names())
+    for (auto p : registry)
     {
-        std::cout << p << std::endl;
+        std::cout << p.first << std::endl;
     }
 
     // create data to accumulate
     std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
     // create and use plugin_accumulator_max
-    auto factory_max = registry.create_factory("plugin_accumulator_max");
-    auto acc_max = factory_max->create();
+    auto acc_max = registry["plugin_accumulator_max"]->create();
     auto result_max = acc_max->accumulate(data);
     std::cout << "accumulator " << acc_max->name() << " result: " << result_max << std::endl;
 
     // create and use plugin_accumulator_min
-    auto factory_min = registry.create_factory("plugin_accumulator_min");
-    auto acc_min = factory_min->create();
+    auto acc_min = registry["plugin_accumulator_min"]->create();
     auto result_min = acc_min->accumulate(data);
     std::cout << "accumulator " << acc_min->name() << " result: " << result_min << std::endl;
 }

examples/custom_factory_with_metadata/custom_factory_with_metadata_plugin_a.cpp

@@ -24,9 +24,9 @@ class PluginAFactory : public PluginFactoryBase
   public:
     using factory_base_type = PluginFactoryBase;
 
-    PluginBase *create() override
+    std::unique_ptr<PluginBase> create() override
     {
-        return new PluginA();
+        return std::make_unique<PluginA>();
     }
 
     std::string name() const override

examples/custom_factory_with_metadata/custom_factory_with_metadata_plugin_b.cpp

@@ -24,9 +24,9 @@ class PluginBFactory : public PluginFactoryBase
   public:
     using factory_base_type = PluginFactoryBase;
 
-    PluginBase *create() override
+    std::unique_ptr<PluginBase> create() override
     {
-        return new PluginB();
+        return std::make_unique<PluginB>();
     }
 
     std::string name() const override

examples/custom_factory_with_metadata/custom_factory_with_metadata_plugin_base.hpp

@@ -1,6 +1,7 @@
 #ifndef CUSTOM_FACTORY_WITH_METADATA_PLUGIN_BASE_HPP
 #define CUSTOM_FACTORY_WITH_METADATA_PLUGIN_BASE_HPP
 
+#include <memory>
 #include <string>
 
 class PluginBase
@@ -19,7 +20,7 @@ class PluginFactoryBase
     virtual ~PluginFactoryBase() = default;
 
     // the factory method
-    virtual PluginBase *create() = 0;
+    virtual std::unique_ptr<PluginBase> create() = 0;
 
     // some additional metadata
     virtual std::string name() const = 0;

examples/custom_factory_with_metadata/main_custom_factory_with_metadata.cpp

@@ -14,19 +14,18 @@ int main(int argc, char **argv)
     std::string plugin_directory = argv[1];
 
     using factory_base_type = PluginFactoryBase;
-    auto &registry = xp::get_registry<factory_base_type>();
-    registry.add_from_directory(plugin_directory);
+    using plugin_registry_type = xp::xplugin_registry<factory_base_type>;
+    plugin_registry_type registry(plugin_directory);
 
-    for (auto &p : registry.plugin_names())
+    for (auto [name, factory] : registry)
     {
-        auto factory = registry.create_factory(p);
 
-        std::cout << "plugin " << p << " factory metadata: " << std::endl;
+        std::cout << "plugin " << name << " factory metadata: " << std::endl;
         std::cout << "  name: " << factory->name() << std::endl;
         std::cout << "  description: " << factory->description() << std::endl;
         std::cout << "  version: " << factory->version() << std::endl;
 
         auto instance = factory->create();
-        std::cout << "plugin " << p << " says: " << instance->some_function() << std::endl;
+        std::cout << "plugin " << name << " says: " << instance->some_function() << std::endl;
     }
 }

examples/fubar/main_fubar.cpp

@@ -16,19 +16,11 @@ int main(int argc, char **argv)
     using factory_type = xp::xfactory_base<fubar::FubarBase, const std::string &>;
     using plugin_registry_type = xp::xplugin_registry<factory_type>;
 
-    plugin_registry_type registry;
-    registry.add_from_directory(plugin_directory);
+    plugin_registry_type registry(plugin_directory);
 
-    std::cout << "available plugins:" << std::endl;
-    for (auto &p : registry.plugin_names())
+    for (auto [name, factory] : registry)
     {
-        std::cout << p << std::endl;
-    }
-
-    for (auto &p : registry.plugin_names())
-    {
-        auto factory = registry.create_factory(p);
         auto instance = factory->create("main_fubar");
-        std::cout << "plugin " << p << " says: " << instance->fubar() << std::endl;
+        std::cout << "plugin " << name << " says: " << instance->fubar() << std::endl;
     }
 }

examples/fubar/plugin_bar.cpp

@@ -4,7 +4,8 @@
 class Bar : public fubar::FubarBase
 {
   public:
-    Bar(const std::string name) : name_(name)
+    Bar(const std::string name)
+        : name_(name)
     {
     }
     virtual ~Bar() = default;

examples/fubar/plugin_foo.cpp

@@ -4,7 +4,8 @@
 class Foo : public fubar::FubarBase
 {
   public:
-    Foo(const std::string name) : name_(name)
+    Foo(const std::string name)
+        : name_(name)
     {
     }
 

examples/serialize/main_serialize.cpp

@@ -36,24 +36,22 @@ int main(int argc, char **argv)
 
     // the type base type of the factory
     using factory_base_type = xp::xfactory_base<SerializeBase>;
+    using plugin_registry_type = xp::xplugin_registry<factory_base_type>;
 
-    // get the plugin registry for that base type
-    auto &registry = xp::get_registry<factory_base_type>();
-
-    // add plugins from the plugin directory
-    registry.add_from_directory(plugin_directory);
+    // create the registry
+    plugin_registry_type registry(plugin_directory);
 
     // some data to serialize / deserialize
     std::unordered_map<std::string, double> data = {{"a", 1}, {"b", 2}, {"c", 3}};
 
     // use all plugins
     ///////////////////////////////////////////
-    for (const auto &plugin_name : registry.plugin_names())
+    for (auto [plugin_name, factory] : registry)
     {
         // create and use plugin_serialize_json
-        auto plugin = registry.create_factory(plugin_name)->create();
+        auto plugin = factory->create();
         auto serialized = plugin->serialize(data);
-        std::cout << "serialized with" << plugin->name() << ":" << std::endl << serialized << std::endl;
+        std::cout << plugin_name << " serialized with" << plugin->name() << ":" << std::endl << serialized << std::endl;
 
         // deserialize with plugin_serialize_json
         auto deserialized = plugin->deserialize(serialized);

include/xplugin/xlazy_shared_library_plugin_factory.hpp

@@ -0,0 +1,82 @@
+/***************************************************************************
+ * Copyright (c) 2023, Dr. Thorsten Beier                                   *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+#ifndef XLAZY_SHARED_LIBRARY_PLUGIN_FACTORY_HPP
+#define XLAZY_SHARED_LIBRARY_PLUGIN_FACTORY_HPP
+
+#include <filesystem>
+#include <memory>
+#include <xplugin/xshared_library.hpp>
+#include <xplugin/xthreads.hpp>
+
+namespace xp
+{
+
+// lazy storage of a shared library
+// and the factory it contains.
+// Both are loaded / created on demand
+template <class FACTORY_BASE, bool THREAD_SAFE>
+class xlazy_shared_library_plugin_factory
+{
+  public:
+    using factory_base_type = FACTORY_BASE;
+    xlazy_shared_library_plugin_factory(const xlazy_shared_library_plugin_factory &) = delete;
+    xlazy_shared_library_plugin_factory &operator=(const xlazy_shared_library_plugin_factory &) = delete;
+
+    xlazy_shared_library_plugin_factory(xlazy_shared_library_plugin_factory &&other) = delete;
+    xlazy_shared_library_plugin_factory &operator=(xlazy_shared_library_plugin_factory &&other) = delete;
+
+    ~xlazy_shared_library_plugin_factory() = default;
+
+    inline xlazy_shared_library_plugin_factory(const std::filesystem::path &path);
+
+    inline const std::filesystem::path &path() const noexcept;
+
+    factory_base_type *factory() const;
+
+  private:
+    using create_plugin_factory_type = factory_base_type *(*)();
+    using mutex_type = xmutex_t<THREAD_SAFE>;
+    using scoped_lock_type = xscoped_lock_t<THREAD_SAFE, mutex_type>;
+
+    mutable mutex_type m_mutex;
+    std::filesystem::path m_path;
+    mutable std::unique_ptr<xshared_library> m_library;
+    mutable std::unique_ptr<factory_base_type> m_factory;
+};
+
+template <class FACTORY_BASE, bool THREAD_SAFE>
+inline xlazy_shared_library_plugin_factory<FACTORY_BASE, THREAD_SAFE>::xlazy_shared_library_plugin_factory(
+    const std::filesystem::path &path)
+    : m_path(path),
+      m_library()
+{
+}
+
+template <class FACTORY_BASE, bool THREAD_SAFE>
+inline typename xlazy_shared_library_plugin_factory<FACTORY_BASE, THREAD_SAFE>::factory_base_type *
+xlazy_shared_library_plugin_factory<FACTORY_BASE, THREAD_SAFE>::factory() const
+{
+    scoped_lock_type lock(m_mutex);
+    if (!m_factory)
+    {
+
+        m_library.reset(new xshared_library(m_path));
+        m_factory.reset(m_library->find_symbol<create_plugin_factory_type>("create_plugin_factory")());
+    }
+    return m_factory.get();
+}
+
+template <class FACTORY_BASE, bool THREAD_SAFE>
+const std::filesystem::path &xlazy_shared_library_plugin_factory<FACTORY_BASE, THREAD_SAFE>::path() const noexcept
+{
+    return m_path;
+}
+
+} // namespace xp
+
+#endif // XLAZY_SHARED_LIBRARY_PLUGIN_FACTORY_HPP