Allow setting/getting global variables in Plugins

include/ppplugin/c/plugin.h

@@ -31,6 +31,25 @@ class CPlugin {
             plugin_, function_name, std::forward<Args>(args)...);
     }
 
+    // TODO: remove code duplication here and in C++ plugin
+    template <typename VariableType>
+    CallResult<VariableType> 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>
+    void 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);
+        }
+    }
+
 private:
     CPlugin() = default;
 

include/ppplugin/cpp/plugin.h

@@ -42,6 +42,24 @@ class CppPlugin {
             plugin_, function_name, std::forward<Args>(args)...);
     }
 
+    template <typename VariableType>
+    CallResult<VariableType> 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>
+    void 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);
+        }
+    }
+
 private:
     CppPlugin() = default;
 

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)

include/ppplugin/lua/lua_script.h

@@ -39,6 +39,24 @@ class LuaScript {
         return { CallError::Code::symbolNotFound };
     }
 
+    template <typename VariableType>
+    CallResult<VariableType> global(const std::string& variable_name)
+    {
+        if (state_.pushGlobal(variable_name)) {
+            if (auto value = state_.pop<VariableType>()) {
+                return value.value();
+            }
+            return { CallError::Code::unknown };
+        }
+        return { CallError::Code::symbolNotFound };
+    }
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value)
+    {
+        state_.push(new_value);
+        state_.markGlobal(variable_name);
+    }
+
 private:
     LuaScript();
 

include/ppplugin/lua/plugin.h

@@ -47,6 +47,17 @@ class LuaPlugin {
         return script_.call<ReturnValue>(function_name, std::forward<Args>(args)...);
     }
 
+    template <typename VariableType>
+    CallResult<VariableType> global(const std::string& variable_name)
+    {
+        return script_.global<VariableType>(variable_name);
+    }
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value)
+    {
+        script_.global(variable_name, std::forward<VariableType>(new_value));
+    }
+
 private:
     explicit LuaPlugin(LuaScript&& script)
         : script_ { std::move(script) }

include/ppplugin/plugin.h

@@ -57,6 +57,17 @@ class GenericPlugin {
     template <typename ReturnValue, typename... Args>
     [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
 
+    template <typename VariableType>
+    CallResult<VariableType> global(const std::string& variable_name)
+    {
+        return plugin_.global(variable_name);
+    }
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value)
+    {
+        plugin_.global(variable_name, std::forward<VariableType>(new_value));
+    }
+
     template <typename P>
     std::optional<std::reference_wrapper<P>> plugin();
 

include/ppplugin/python/plugin.h

@@ -27,6 +27,17 @@ class PythonPlugin {
     template <typename ReturnValue, typename... Args>
     [[nodiscard]] CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
 
+    template <typename VariableType>
+    CallResult<VariableType> global(const std::string& variable_name)
+    {
+        return interpreter_.global<VariableType>(variable_name);
+    }
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value)
+    {
+        interpreter_.global(variable_name, std::forward<VariableType>(new_value));
+    }
+
 private:
     PythonPlugin() = default;
 

include/ppplugin/python/python_interpreter.h

@@ -20,6 +20,22 @@ class PythonInterpreter {
     template <typename ReturnValue, typename... Args>
     CallResult<ReturnValue> call(const std::string& function_name, Args&&... args);
 
+    template <typename VariableType>
+    CallResult<VariableType> global(const std::string& variable_name)
+    {
+        // TODO implement global for Python
+        (void)variable_name;
+        throw std::logic_error { "unimplemented" };
+    }
+    template <typename VariableType>
+    void global(const std::string& variable_name, VariableType&& new_value)
+    {
+        // TODO implement global for Python
+        (void)variable_name;
+        (void)new_value;
+        throw std::logic_error { "unimplemented" };
+    }
+
 private:
     PyThreadState* state() { return state_.get(); }
     PyObject* mainModule() { return main_module_.get(); }

src/boost_dll_loader.cpp

@@ -10,7 +10,7 @@
 #include <boost/filesystem/path.hpp>
 
 namespace {
-std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library& library, const std::string& function_name)
+[[nodiscard]] std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (!library.is_loaded()) {
         return ppplugin::CallError::Code::notLoaded;
@@ -25,7 +25,7 @@ std::optional<ppplugin::CallError> isCallable(const boost::dll::shared_library&
 } // namespace
 
 namespace ppplugin::detail::boost_dll {
-[[nodiscard]] CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+CallResult<void*> getFunctionSymbol(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (auto error = isCallable(library, function_name)) {
         return { *error };
@@ -41,7 +41,7 @@ namespace ppplugin::detail::boost_dll {
     return { CallError::Code::unknown };
 }
 
-[[nodiscard]] CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+CallResult<void*> getFunctionPointerSymbol(const boost::dll::shared_library& library, const std::string& function_name)
 {
     if (auto error = isCallable(library, function_name)) {
         return { *error };
@@ -57,13 +57,23 @@ namespace ppplugin::detail::boost_dll {
     return { CallError::Code::unknown };
 }
 
-/**
- * Attempt to load shared library from given path.
- *
- * Returned library object is not necessarily loaded, check
- * boost::dll::shared_library::is_loaded().
- */
-[[nodiscard]] std::optional<boost::dll::shared_library> loadSharedLibrary(
+CallResult<void**> getSymbol(const boost::dll::shared_library& library, const std::string& function_name)
+{
+    if (auto error = isCallable(library, function_name)) {
+        return { *error };
+    }
+    try {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        if (auto** symbol = &library.get<void*>(function_name)) {
+            return symbol;
+        }
+    } catch (const std::exception& exception) {
+        return CallError { CallError::Code::unknown, exception.what() };
+    }
+    return { CallError::Code::unknown };
+}
+
+std::optional<boost::dll::shared_library> loadSharedLibrary(
     const std::filesystem::path& plugin_library_path)
 {
     if (!std::filesystem::exists(plugin_library_path)) {