Allow setting/getting global variables in Plugins

.clang-tidy

@@ -6,13 +6,13 @@ Checks: >
         google-*,-google-readability-todo,-google-readability-braces-around-statements,
         hicpp-*,-hicpp-braces-around-statements,-hicpp-use-emplace,-hicpp-named-parameter,
           -hicpp-no-array-decay,-hicpp-uppercase-literal-suffix,
-        misc-*,-misc-no-recursion,
+        misc-*,-misc-include-cleaner,-misc-no-recursion,
         bugprone-*,
         boost-*,
         cert-*,-cert-dcl16-c,-cert-dcl51-cpp,-cert-dcl37-c,
         concurrency-*,
         cppcoreguidelines-*,-cppcoreguidelines-avoid-magic-numbers,
-        modernize-*,-modernize-use-trailing-return-type,-modernize-use-emplace,
+        modernize-*,-modernize-use-trailing-return-type,-modernize-use-emplace,-modernize-use-designated-initializers,
         performance-*,-performance-noexcept-move-constructor,
         portability-*,
         readability-*,-readability-redundant-access-specifiers

.github/workflows/cpp-format.yml

@@ -28,9 +28,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: jirutka/setup-alpine@v1
         with:
-          branch: v3.19
+          branch: v3.21
           packages: >
-            clang-extra-tools
+            clang19-extra-tools
 
       # Check all source and header C++ files; ignore files in hidden directories
       - name: Execute clang-format

.github/workflows/cpp-lint.yml

@@ -32,7 +32,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: jirutka/setup-alpine@v1
         with:
-          branch: v3.19
+          branch: v3.21
           packages: >
             cmake
             ninja-build
@@ -44,7 +44,7 @@ jobs:
             python3-dev
             fmt-dev
             gtest-dev
-            clang-extra-tools
+            clang19-extra-tools
       - name: Fixup environment
         run: |
           ln -s liblua-5.2.so.0 /usr/lib/liblua-5.2.so

examples/configurable_plugin/configurable_plugin_manager.cpp

@@ -32,12 +32,10 @@ int main(int argc, char* argv[])
         if (!a_1 || !a_2) {
             return 2;
         }
-        auto unwrapped_a_1 = *a_1;
-        auto unwrapped_a_2 = *a_2;
 
         std::atomic<bool> stop_signal { false };
-        std::thread thread_1([plugin = unwrapped_a_1, &stop_signal]() { plugin->loop(stop_signal); });
-        std::thread thread_2([plugin = unwrapped_a_2, &stop_signal]() { plugin->loop(stop_signal); });
+        std::thread thread_1([plugin = *a_1, &stop_signal]() { plugin->loop(stop_signal); });
+        std::thread thread_2([plugin = *a_2, &stop_signal]() { plugin->loop(stop_signal); });
         std::this_thread::sleep_for(std::chrono::seconds { 5 });
         stop_signal.store(true);
         thread_1.join();

examples/multi_language_plugin/multi_language_plugin_manager.cpp

@@ -40,12 +40,12 @@ int main(int argc, char* argv[])
             plugins.push_back(std::move(*plugin));
         }
         plugins.push_back(manager.loadCPlugin(non_existant_lib_path)
-                              .andThen([](const auto& plugin) {
-                                  // convert to generic plugin
-                                  return ppplugin::Plugin { plugin };
-                              })
-                              // silently fail and use no-op plugin instead
-                              .valueOr(ppplugin::NoopPlugin {}));
+                .andThen([](const auto& plugin) {
+                    // convert to generic plugin
+                    return ppplugin::Plugin { plugin };
+                })
+                // silently fail and use no-op plugin instead
+                .valueOr(ppplugin::NoopPlugin {}));
         for (auto& plugin : plugins) {
             plugin.call<void>("initialize").valueOrElse([](const ppplugin::CallError& error) {
                 std::cerr << "Initialize Error: " << error.what() << '\n';
@@ -54,7 +54,7 @@ int main(int argc, char* argv[])
         for (int counter {}; counter < std::numeric_limits<int>::max(); ++counter) {
             for (auto& plugin : plugins) {
                 // explicit cast to int to avoid passing by reference
-                plugin.call<void>("loop", static_cast<int>(counter))
+                plugin.call<void>("loop", static_cast<int>(counter)) // NOLINT(readability-redundant-casting)
                     .valueOrElse([](const ppplugin::CallError& error) {
                         std::cerr << "Loop Error: " << error.what() << '\n';
                     });

examples/multi_language_plugin/plugins/cpp_plugin.cpp

@@ -2,7 +2,7 @@
 
 #include <boost/dll/alias.hpp>
 
-void initialize()
+extern void initialize()
 {
     std::cout << "C++ initialize" << '\n';
 }

examples/simple_plugin/simple_plugin_manager.cpp

@@ -4,7 +4,6 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <string_view>
 #include <thread>
 
 #include "ppplugin/cpp/plugin.h"
@@ -13,43 +12,25 @@
 
 #include "simple_plugin.h"
 
-void printError(std::string_view function_name, const ppplugin::CallError& error)
-{
-    const std::string_view error_string = error == ppplugin::CallError::Code::symbolNotFound ? "not found"
-        : error == ppplugin::CallError::Code::notLoaded                                      ? "not loaded"
-        : error == ppplugin::CallError::Code::unknown                                        ? "unknown error"
-                                                                                             : "other error";
-    std::cerr << "Unable to call '" << function_name << "' ('" << error_string
-              << "')!\n";
-}
-
-void printError(std::string_view plugin_name, ppplugin::LoadError error)
-{
-    using ppplugin::LoadError;
-    const std::string_view error_string = error == LoadError::fileNotFound ? "not found"
-        : error == LoadError::fileInvalid                                  ? "invalid"
-        : error == LoadError::unknown                                      ? "unknown error"
-                                                                           : "other error";
-    std::cerr << "Unable to load '" << plugin_name << "' ('" << error_string
-              << "')!\n";
-}
-
+namespace {
 template <typename ClassType>
 std::thread initializeAndLoop(ppplugin::CppPlugin& plugin, const std::string& function_name)
 {
-    auto plugin_a = plugin.call<std::shared_ptr<ClassType>>(function_name);
-    if (plugin_a) {
-        auto& plugin = *plugin_a;
+    auto result = plugin.call<std::shared_ptr<ClassType>>(function_name);
+    if (result) {
+        auto& plugin = *result;
         plugin->initialize();
         return std::thread { [plugin]() {
             plugin->loop();
         } };
     }
     // NOLINTNEXTLINE(bugprone-unchecked-optional-access); checked in previous if
-    return std::thread { [function_name, error = *plugin_a.error()]() {
-        printError(function_name, error);
+    return std::thread { [function_name, error = *result.error()]() {
+        std::cerr << "Unable to call '" << function_name
+                  << "' ('" << ppplugin::codeToString(error.code()) << "')!\n";
     } };
 }
+} // namespace
 
 int main(int argc, char* argv[])
 {
@@ -59,14 +40,14 @@ int main(int argc, char* argv[])
         }
         auto executable_dir = std::filesystem::path { argv[0] }.parent_path();
         auto library_path = executable_dir / "libsimple_plugin.so";
-        // setup manager - has to stay alive for as long as you want to use the
-        // plugins
+        // setup manager - has to stay alive for as long as you want to use the plugins
         ppplugin::GenericPluginManager<SimplePluginInterface> manager;
         // load plugin library and exit on error
-        auto plugin_library = manager.loadCppPlugin(std::filesystem::path { library_path }).valueOrElse([](const auto& error) -> ppplugin::CppPlugin {
-            printError("simple_plugin_a", error);
-            std::exit(1); // NOLINT(concurrency-mt-unsafe)
-        });
+        auto plugin_library = manager.loadCppPlugin(std::filesystem::path { library_path })
+                                  .valueOrElse([](const auto& error) -> ppplugin::CppPlugin {
+                                      std::cerr << "Unable to load plugin: " << ppplugin::codeToString(error);
+                                      std::exit(1); // NOLINT(concurrency-mt-unsafe)
+                                  });
 
         auto thread_a = initializeAndLoop<SimplePluginA>(plugin_library, "create_a");
         auto thread_b = initializeAndLoop<SimplePluginInterface>(plugin_library, "create_b");

include/ppplugin/c/plugin.h

@@ -7,36 +7,60 @@
 namespace ppplugin {
 class CPlugin {
 public:
-    static Expected<CPlugin, LoadError> load(
-        const std::filesystem::path& plugin_library_path)
-    {
-        if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
-            CPlugin new_plugin;
-            new_plugin.plugin_ = *shared_library;
-            return new_plugin;
-        }
-        return LoadError::unknown;
-    }
+    [[nodiscard]] static Expected<CPlugin, LoadError> load(const std::filesystem::path& plugin_library_path);
+
+    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+    operator bool() const;
 
     template <typename ReturnValue, typename... Args>
-    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        static_assert(!std::is_reference_v<ReturnValue>,
-            "C does not support references for its return value!");
-        static_assert(!(std::is_reference_v<Args> || ...),
-            "C does not support references for its arguments! "
-            "Consider passing the argument with an explicit cast to the desired type.");
-
-        return detail::boost_dll::call<false, ReturnValue>(
-            plugin_, function_name, std::forward<Args>(args)...);
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     CPlugin() = default;
 
 private:
     boost::dll::shared_library plugin_;
 };
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> CPlugin::call(const std::string& function_name, Args&&... args)
+{
+    static_assert(!std::is_reference_v<ReturnValue>,
+        "C does not support references for its return value!");
+    static_assert(!(std::is_reference_v<Args> || ...),
+        "C does not support references for its arguments! "
+        "Consider passing the argument with an explicit cast to the desired type.");
+
+    return detail::boost_dll::call<false, ReturnValue>(
+        plugin_, function_name, std::forward<Args>(args)...);
+}
+
+// TODO: remove code duplication here and in C++ plugin
+template <typename VariableType>
+CallResult<VariableType> CPlugin::global(const std::string& variable_name)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        return *reinterpret_cast<VariableType*>(p.value().value());
+    }
+    return { p.error().value() };
+}
+
+template <typename VariableType>
+CallResult<void> CPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        *reinterpret_cast<VariableType*>(p.value().value()) = std::forward<VariableType>(new_value);
+        return {};
+    }
+    return { p.error().value() };
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_C_PLUGIN_H

include/ppplugin/cpp/plugin.h

@@ -12,16 +12,7 @@
 namespace ppplugin {
 class CppPlugin {
 public:
-    static Expected<CppPlugin, LoadError> load(
-        const std::filesystem::path& plugin_library_path)
-    {
-        if (auto shared_library = detail::boost_dll::loadSharedLibrary(plugin_library_path)) {
-            CppPlugin new_plugin;
-            new_plugin.plugin_ = *shared_library;
-            return new_plugin;
-        }
-        return LoadError::unknown;
-    }
+    [[nodiscard]] static Expected<CppPlugin, LoadError> load(const std::filesystem::path& plugin_library_path);
 
     ~CppPlugin() = default;
     CppPlugin(const CppPlugin&) = default;
@@ -30,24 +21,50 @@ class CppPlugin {
     CppPlugin& operator=(CppPlugin&&) = default;
 
     // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
-    operator bool() const
-    {
-        return plugin_.is_loaded();
-    }
+    operator bool() const;
 
     template <typename ReturnValue, typename... Args>
-    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args)
-    {
-        return detail::boost_dll::call<true, ReturnValue>(
-            plugin_, function_name, std::forward<Args>(args)...);
-    }
+    [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
+
+    template <typename VariableType>
+    [[nodiscard]] CallResult<VariableType> global(const std::string& variable_name);
+    template <typename VariableType>
+    [[nodiscard]] CallResult<void> global(const std::string& variable_name, VariableType&& new_value);
 
 private:
     CppPlugin() = default;
 
 private:
     boost::dll::shared_library plugin_;
 };
+
+template <typename ReturnValue, typename... Args>
+CallResult<ReturnValue> CppPlugin::call(const std::string& function_name, Args&&... args)
+{
+    return detail::boost_dll::call<true, ReturnValue>(
+        plugin_, function_name, std::forward<Args>(args)...);
+}
+
+template <typename VariableType>
+CallResult<VariableType> CppPlugin::global(const std::string& variable_name)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        return *reinterpret_cast<VariableType*>(p.value().value());
+    }
+    return { p.error().value() };
+}
+
+template <typename VariableType>
+CallResult<void> CppPlugin::global(const std::string& variable_name, VariableType&& new_value)
+{
+    auto p = detail::boost_dll::getSymbol(plugin_, variable_name);
+    if (p.hasValue()) {
+        *reinterpret_cast<VariableType*>(p.value().value()) = std::forward<VariableType>(new_value);
+        return {};
+    }
+    return { p.error().value() };
+}
 } // namespace ppplugin
 
 #endif // PPPLUGIN_CPP_PLUGIN_H

include/ppplugin/detail/boost_dll_loader.h

@@ -20,6 +20,7 @@ namespace ppplugin::detail::boost_dll {
 
 [[nodiscard]] CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name);
 [[nodiscard]] CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name);
+[[nodiscard]] CallResult<void**> getSymbol(const boost::dll::shared_library& library, const std::string& function_name);
 
 template <bool isPointer, typename ReturnValue, typename... Args>
 [[nodiscard]] CallResult<ReturnValue> call(const boost::dll::shared_library& library, const std::string& function_name, Args&&... args)