diff options
Diffstat (limited to 'src/Bindings/PluginLua.h')
| -rw-r--r-- | src/Bindings/PluginLua.h | 86 |
1 files changed, 55 insertions, 31 deletions
diff --git a/src/Bindings/PluginLua.h b/src/Bindings/PluginLua.h index e53fbaaa8..db6612671 100644 --- a/src/Bindings/PluginLua.h +++ b/src/Bindings/PluginLua.h @@ -10,6 +10,7 @@ #pragma once #include "Plugin.h" +#include "WebPlugin.h" #include "LuaState.h" // Names for the global variables through which the plugin is identified in its LuaState @@ -28,7 +29,8 @@ class cWindow; // tolua_begin class cPluginLua : - public cPlugin + public cPlugin, + public cWebPlugin { typedef cPlugin super; @@ -62,6 +64,36 @@ public: + /** A base class that represents something related to a plugin + The plugin can reset this class so that the instance can continue to exist but will not engage the (possibly non-existent) plugin anymore. + This is used for scheduled tasks etc., so that they can be queued and reset when the plugin is terminated, without removing them from the queue. */ + class cResettable + { + public: + /** Creates a new instance bound to the specified plugin. */ + cResettable(cPluginLua & a_Plugin); + + // Force a virtual destructor in descendants: + virtual ~cResettable() {} + + /** Resets the plugin instance stored within. + The instance will continue to exist, but should not call into the plugin anymore. */ + virtual void Reset(void); + + protected: + /** The plugin that this instance references. + If nullptr, the plugin has already unloaded and the instance should bail out any processing. + Protected against multithreaded access by m_CSPlugin. */ + cPluginLua * m_Plugin; + + /** The mutex protecting m_Plugin against multithreaded access. */ + cCriticalSection m_CSPlugin; + }; + + typedef SharedPtr<cResettable> cResettablePtr; + typedef std::vector<cResettablePtr> cResettablePtrs; + + cPluginLua(const AString & a_PluginDirectory); ~cPluginLua(); @@ -149,6 +181,14 @@ public: /** Returns true if the plugin contains the function for the specified hook type, using the old-style registration (#121) */ bool CanAddOldStyleHook(int a_HookType); + // cWebPlugin overrides + virtual const AString GetWebTitle(void) const override {return GetName(); } + virtual AString HandleWebRequest(const HTTPRequest & a_Request) override; + + /** Adds a new web tab to webadmin. + Displaying the tab calls the referenced function. */ + bool AddWebTab(const AString & a_Title, lua_State * a_LuaState, int a_FunctionReference); // Exported in ManualBindings.cpp + /** Binds the command to call the function specified by a Lua function reference. Simply adds to CommandMap. */ void BindCommand(const AString & a_Command, int a_FnRef); @@ -171,9 +211,11 @@ public: /** Returns the name of Lua function that should handle the specified hook type in the older (#121) API */ static const char * GetHookFnName(int a_HookType); - /** Adds a Lua callback to be called for the specified hook. - Returns true if the hook was added successfully. */ - bool AddHookCallback(int a_HookType, cLuaState::cCallbackPtr a_Callback); + /** Adds a Lua function to be called for the specified hook. + The function has to be on the Lua stack at the specified index a_FnRefIdx + Returns true if the hook was added successfully. + */ + bool AddHookRef(int a_HookType, int a_FnRefIdx); /** Calls a function in this plugin's LuaState with parameters copied over from a_ForeignState. The values that the function returns are placed onto a_ForeignState. @@ -193,23 +235,29 @@ public: return m_LuaState.Call(a_Fn, a_Args...); } + /** Adds the specified cResettable instance to m_Resettables, so that it is notified when the plugin is being closed. */ + void AddResettable(cResettablePtr a_Resettable); + protected: /** Maps command name into Lua function reference */ typedef std::map<AString, int> CommandMap; /** Provides an array of Lua function references */ - typedef std::vector<cLuaState::cCallbackPtr> cLuaCallbacks; + typedef std::vector<cLuaState::cRef *> cLuaRefs; /** Maps hook types into arrays of Lua function references to call for each hook type */ - typedef std::map<int, cLuaCallbacks> cHookMap; + typedef std::map<int, cLuaRefs> cHookMap; - /** The mutex protecting m_LuaState against multithreaded use. */ + /** The mutex protecting m_LuaState and each of the m_Resettables[] against multithreaded use. */ cCriticalSection m_CriticalSection; /** The plugin's Lua state. */ cLuaState m_LuaState; + /** Objects that need notification when the plugin is about to be unloaded. */ + cResettablePtrs m_Resettables; + /** In-game commands that the plugin has registered. */ CommandMap m_Commands; @@ -222,30 +270,6 @@ protected: /** Releases all Lua references, notifies and removes all m_Resettables[] and closes the m_LuaState. */ void Close(void); - - /** Removes all WebTabs currently registered for this plugin from the WebAdmin. */ - void ClearWebTabs(void); - - /** Calls a hook that has the simple format - single bool return value specifying whether the chain should continue. - The advanced hook types that need more processing implement a similar loop manually instead. - Returns true if any of hook calls wants to abort the hook (returned true), false if all hook calls returned false. */ - template <typename... Args> - bool CallSimpleHooks(int a_HookType, Args && ... a_Args) - { - cCSLock lock(m_CriticalSection); - auto & hooks = m_HookMap[a_HookType]; - bool res = false; - for (auto & hook: hooks) - { - hook->Call(std::forward<Args>(a_Args)..., cLuaState::Return, res); - if (res) - { - // Hook wants to terminate the chain processing - return true; - } - } - return false; - } } ; // tolua_export |