Changeset 10580

Timestamp:

Sep 12, 2015, 4:10:02 PM (9 years ago)

Author:

landauf

Message:

it's now possible to define required plugins in the level definition (in XML)

Location:

code/branches/core7/src

Files:

• libraries/core/CorePrereqs.h (modified) (1 diff)
• libraries/core/module/CMakeLists.txt (modified) (1 diff)
• libraries/core/module/PluginManager.cc (modified) (5 diffs)
• libraries/core/module/PluginManager.h (modified) (1 diff)
• libraries/core/module/PluginReference.cc (added)
• libraries/core/module/PluginReference.h (added)
• orxonox/Level.cc (modified) (4 diffs)
• orxonox/Level.h (modified) (2 diffs)

code/branches/core7/src/libraries/core/CorePrereqs.h

@@ -212 +212 @@
     class Plugin;
     class PluginManager;
+    class PluginReference;
     struct ResourceInfo;
     template <ScopeID::Value>

code/branches/core7/src/libraries/core/module/CMakeLists.txt

@@ -5 +5 @@
   Plugin.cc
   PluginManager.cc
+  PluginReference.cc
   StaticallyInitializedInstance.cc
   StaticInitializationHandlerIncludes.cc

code/branches/core7/src/libraries/core/module/PluginManager.cc

@@ -33 +33 @@
 #include "SpecialConfig.h"
 #include "Plugin.h"
+#include "PluginReference.h"
 #include "core/ApplicationPaths.h"
 #include "core/command/ConsoleCommandIncludes.h"
+#include "core/object/Context.h"
 
 namespace orxonox
 {
-    SetConsoleCommand("PluginManager", "load", &PluginManager::loadPlugin);
-    SetConsoleCommand("PluginManager", "unload", &PluginManager::unloadPlugin);
+    static const std::string __CC_PluginManager_load_name  = "load";
+    static const std::string __CC_PluginManager_unload_name  = "unload";
+
+    SetConsoleCommand("PluginManager", __CC_PluginManager_load_name, &PluginManager::loadPlugin);
+    SetConsoleCommand("PluginManager", __CC_PluginManager_unload_name, &PluginManager::unloadPlugin);
 
     PluginManager* PluginManager::singletonPtr_s  = 0;
@@ -45 +50 @@
     PluginManager::PluginManager()
     {
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(this);
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(this);
     }
 
     PluginManager::~PluginManager()
     {
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(NULL);
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(NULL);
+
+        for (std::map<std::string, PluginReference*>::iterator it = this->references_.begin(); it != this->references_.end(); ++it)
+            delete it->second;
         for (std::map<std::string, Plugin*>::iterator it = this->plugins_.begin(); it != this->plugins_.end(); ++it)
             delete it->second;
@@ -74 +86 @@
     }
 
-    /*static*/ void PluginManager::loadPlugin(const std::string& name)
+    void PluginManager::referencePlugin(const std::string& name)
     {
-        Plugin* plugin = PluginManager::getInstance().plugins_[name];
+        Plugin* plugin = this->plugins_[name];
         if (plugin != NULL)
             plugin->load();
@@ -83 +95 @@
     }
 
-    /*static*/ void PluginManager::unloadPlugin(const std::string& name)
+    void PluginManager::dereferencePlugin(const std::string& name)
     {
-        Plugin* plugin = PluginManager::getInstance().plugins_[name];
+        Plugin* plugin = this->plugins_[name];
         if (plugin != NULL)
             plugin->unload();
@@ -91 +103 @@
             orxout(internal_warning) << "Cannot find plugin with name " << name << endl;
     }
+
+    /**
+     * @brief Console command to manually load a plugin. The plugin stays loaded until @ref unloadPlugin is called.
+     */
+    void PluginManager::loadPlugin(const std::string& name)
+    {
+        if (this->references_[name] == NULL)
+        {
+            this->references_[name] = new PluginReference(name);
+        }
+        else
+            orxout(internal_warning) << "Plugin " << name << " is already loaded" << endl;
+    }
+
+    /**
+     * @brief Console command to unload a plugin if it was previously loaded manually by calling @ref loadPlugin.
+     * Does not unload the plugin immediately if it is still used by another @ref PluginReference (e.g. by a @ref Level).
+     */
+    void PluginManager::unloadPlugin(const std::string& name)
+    {
+        PluginReference* reference = this->references_[name];
+        if (reference != NULL)
+        {
+            this->references_[name] = NULL;
+            delete reference;
+        }
+        else
+            orxout(internal_warning) << "Plugin " << name << " is already unloaded" << endl;
+    }
 }

code/branches/core7/src/libraries/core/module/PluginManager.h

@@ -48 +48 @@
             void findPlugins();
 
-            static void loadPlugin(const std::string& name);
-            static void unloadPlugin(const std::string& name);
+            void referencePlugin(const std::string& name);
+            void dereferencePlugin(const std::string& name);
+
+            // console commands
+            void loadPlugin(const std::string& name);
+            void unloadPlugin(const std::string& name);
 
         private:
             std::map<std::string, Plugin*> plugins_;
+            std::map<std::string, PluginReference*> references_; // references that were created by console command
 
             static PluginManager* singletonPtr_s;

code/branches/core7/src/orxonox/Level.cc

@@ -35 +35 @@
 #include "core/XMLFile.h"
 #include "core/XMLPort.h"
+#include "core/module/PluginReference.h"
 
 #include "infos/PlayerInfo.h"
@@ -65 +66 @@
             if (this->xmlfile_)
                 Loader::getInstance().unload(this->xmlfile_);
+
+            this->unloadPlugins();
         }
     }
@@ -72 +75 @@
         SUPER(Level, XMLPort, xmlelement, mode);
 
+        XMLPortParam(Level, "plugins",  setPluginsString,  getPluginsString,  xmlelement, mode);
         XMLPortParam(Level, "gametype", setGametypeString, getGametypeString, xmlelement, mode).defaultValues("Gametype");
 
@@ -106 +110 @@
             Template::getTemplate(*it)->applyOn(this);
         }
+    }
+
+    void Level::setPluginsString(const std::string& pluginsString)
+    {
+        // unload old plugins
+        this->unloadPlugins();
+
+        // load new plugins
+        this->pluginsString_ = pluginsString;
+        SubString tokens(pluginsString, ",");
+        for (size_t i = 0; i < tokens.size(); ++i)
+            this->plugins_.push_back(new PluginReference(tokens[i]));
+    }
+
+    void Level::unloadPlugins()
+    {
+        // use destroyLater() - this ensures that plugins are not unloaded too early.
+        // Note: When a level gets unloaded, the Level object is usually the last object that gets destroyed. This is because all other
+        //       objects inside a level have a StrongPtr (in BaseObject) that references the Level object. This means that the Level
+        //       object is only destroyed, when all StrongPtrs that pointed to it were destroyed. But at the time when the last StrongPtr
+        //       is destroyed, the other object is not yet fully destroyed because the StrongPtr is destroyed in ~BaseObject (and this
+        //       means that e.g. ~Identifiable was not yet called for this object). This means that technically there are still other
+        //       objects alive when ~Level is called. This is the reason why we cannot directly destroy() the Plugins - instead we need
+        //       to call destroyLater() to ensure that no instances from this plugin exist anymore.
+        for (std::list<PluginReference*>::iterator it = this->plugins_.begin(); it != this->plugins_.end(); ++it)
+            (*it)->destroyLater();
+        this->plugins_.clear();
     }
 

code/branches/core7/src/orxonox/Level.h

@@ -65 +65 @@
 //            MeshLodInformation* getLodInfo(unsigned int index) const;
 
+            void setPluginsString(const std::string& pluginsString);
+            inline const std::string& getPluginsString() const
+                { return this->pluginsString_; }
+
+            void unloadPlugins();
+
             void setGametypeString(const std::string& gametype);
             inline const std::string& getGametypeString() const
@@ -70 +76 @@
 
             void networkcallback_applyXMLFile();
+
+            std::string                    pluginsString_;
+            std::list<PluginReference*>    plugins_;
 
             std::string                    gametype_;