Changeset 10532

Timestamp:

Jun 6, 2015, 4:38:45 PM (10 years ago)

Author:

landauf

Message:

use CoreStaticInitializationHandler to initialize core instances

Location:

code/branches/core7/src/libraries/core

Files:

• Core.cc (modified) (6 diffs)
• Core.h (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• CoreStaticInitializationHandler.cc (modified) (1 diff)
• CoreStaticInitializationHandler.h (modified) (1 diff)
• module/CMakeLists.txt (modified) (1 diff)
• module/StaticInitializationHandler.cc (deleted)
• module/StaticInitializationHandler.h (modified) (1 diff)
• module/StaticInitializationManager.cc (modified) (2 diffs)
• module/StaticInitializationManager.h (modified) (1 diff)

code/branches/core7/src/libraries/core/Core.cc

@@ -78 +78 @@
 #include "object/ObjectList.h"
 #include "module/ModuleInstance.h"
+#include "module/StaticInitializationManager.h"
+#include "CoreStaticInitializationHandler.h"
 #include "UpdateListener.h"
 
@@ -111 +113 @@
         , graphicsScope_(NULL)
         , bGraphicsLoaded_(false)
+        , staticInitHandler_(NULL)
         , rootModule_(NULL)
         , config_(NULL)
@@ -124 +127 @@
 
         // TODO: initialize StaticInitializationManager
+        this->staticInitHandler_ = new CoreStaticInitializationHandler();
+        StaticInitializationManager::getInstance().addHandler(this->staticInitHandler_);
+
         // TODO: initialize Root-Context
         // TODO: initialize IdentifierManager here
@@ -250 +256 @@
             this->rootModule_->deleteAllStaticallyInitializedInstances();
         }
+        if (this->staticInitHandler_)
+            StaticInitializationManager::getInstance().removeHandler(this->staticInitHandler_);
         Context::setRootContext(NULL);
         safeObjectDelete(&rootModule_);
+        safeObjectDelete(&staticInitHandler_);
         safeObjectDelete(&dynLibManager_);
         safeObjectDelete(&configurablePaths_);
@@ -288 +297 @@
         DynLib* dynLib = this->dynLibManager_->load(module->getName());
         module->setDynLib(dynLib);
-        module->loadAllStaticallyInitializedInstances(0);
-        IdentifierManager::getInstance().createClassHierarchy();
-        ScopeManager::getInstance().updateListeners();
+
+        StaticInitializationManager::getInstance().loadModule(module);
     }
 
@@ -308 +316 @@
         orxout(internal_info) << "Unloading module " << module->getName() << "..." << endl;
 
-        module->unloadAllStaticallyInitializedInstances(0);
+        StaticInitializationManager::getInstance().unloadModule(module);
+
         module->deleteAllStaticallyInitializedInstances();
         this->dynLibManager_->unload(module->getDynLib());

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

@@ -95 +95 @@
             void setThreadAffinity(int limitToCPU);
 
-            ApplicationPaths*         applicationPaths_;
-            ConfigurablePaths*        configurablePaths_;
-            DynLibManager*            dynLibManager_;
-            SignalHandler*            signalHandler_;
-            ConfigFileManager*        configFileManager_;
-            Language*                 languageInstance_;
-            Loader*                   loaderInstance_;
-            IOConsole*                ioConsole_;
-            TclBind*                  tclBind_;
-            TclThreadManager*         tclThreadManager_;
-            Scope<ScopeID::ROOT>*     rootScope_;
+            ApplicationPaths*                applicationPaths_;
+            ConfigurablePaths*               configurablePaths_;
+            DynLibManager*                   dynLibManager_;
+            SignalHandler*                   signalHandler_;
+            ConfigFileManager*               configFileManager_;
+            Language*                        languageInstance_;
+            Loader*                          loaderInstance_;
+            IOConsole*                       ioConsole_;
+            TclBind*                         tclBind_;
+            TclThreadManager*                tclThreadManager_;
+            Scope<ScopeID::ROOT>*            rootScope_;
             // graphical
-            GraphicsManager*          graphicsManager_;            //!< Interface to OGRE
-            InputManager*             inputManager_;               //!< Interface to OIS
-            GUIManager*               guiManager_;                 //!< Interface to GUI
-            Scope<ScopeID::GRAPHICS>* graphicsScope_;
-            bool                      bGraphicsLoaded_;
-            ModuleInstance*           rootModule_;
-            std::list<ModuleInstance*>modules_;
+            GraphicsManager*                 graphicsManager_;            //!< Interface to OGRE
+            InputManager*                    inputManager_;               //!< Interface to OIS
+            GUIManager*                      guiManager_;                 //!< Interface to GUI
+            Scope<ScopeID::GRAPHICS>*        graphicsScope_;
+            bool                             bGraphicsLoaded_;
+
+            CoreStaticInitializationHandler* staticInitHandler_;
+            ModuleInstance*                  rootModule_;
+            std::list<ModuleInstance*>       modules_;
 
             /// Helper object that stores the config values
-            CoreConfig*               config_;
+            CoreConfig*                      config_;
 
             /// Helper object that executes the surrogate destructor destroy()
-            DestructionHelper<Core>   destructionHelper_;
+            DestructionHelper<Core>          destructionHelper_;
 
-            static Core*              singletonPtr_s;
+            static Core*                     singletonPtr_s;
     };
 }

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

@@ -158 +158 @@
     class Core;
     class CoreConfig;
+    class CoreStaticInitializationHandler;
     class Destroyable;
     class DestroyLaterManager;

code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc

@@ -29 +29 @@
 #include "CoreStaticInitializationHandler.h"
 
+#include "module/ModuleInstance.h"
+#include "class/IdentifierManager.h"
+#include "singleton/ScopeManager.h"
+
 namespace orxonox
 {
+    void CoreStaticInitializationHandler::setupHandler()
+    {
+        // TODO
+    }
+
+    void CoreStaticInitializationHandler::shutdownHandler()
+    {
+        // TODO
+    }
+
+    void CoreStaticInitializationHandler::loadModule(ModuleInstance* module)
+    {
+        module->loadAllStaticallyInitializedInstances(0);
+        IdentifierManager::getInstance().createClassHierarchy();
+        ScopeManager::getInstance().updateListeners();
+    }
+
+    void CoreStaticInitializationHandler::unloadModule(ModuleInstance* module)
+    {
+        module->unloadAllStaticallyInitializedInstances(0);
+    }
 }

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

@@ -39 +39 @@
     {
         public:
-            CoreStaticInitializationHandler() {}
-            virtual ~CoreStaticInitializationHandler() {}
+            virtual void setupHandler();
+            virtual void shutdownHandler();
+
+            virtual void loadModule(ModuleInstance* module);
+            virtual void unloadModule(ModuleInstance* module);
     };
 }

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

@@ -2 +2 @@
   ModuleInstance.cc
   StaticallyInitializedInstance.cc
-  StaticInitializationHandler.cc
   StaticInitializationHandlerIncludes.cc
   StaticInitializationManager.cc

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

@@ -39 +39 @@
             StaticInitializationHandler() {}
             virtual ~StaticInitializationHandler() {}
+
+            virtual void setupHandler() = 0;
+            virtual void shutdownHandler() = 0;
+
+            virtual void loadModule(ModuleInstance* module) = 0;
+            virtual void unloadModule(ModuleInstance* module) = 0;
     };
 }

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

@@ -29 +29 @@
 #include "StaticInitializationManager.h"
 
+#include "StaticInitializationHandler.h"
+
 namespace orxonox
 {
@@ -47 +49 @@
     }
 
-    void StaticInitializationManager::addCoreHandler()
+    void StaticInitializationManager::loadModule(ModuleInstance* module)
     {
-        // TODO
+        for (std::list<StaticInitializationHandler*>::iterator it = this->handlers_.begin(); it != this->handlers_.end(); ++it)
+            (*it)->loadModule(module);
+    }
+
+    void StaticInitializationManager::unloadModule(ModuleInstance* module)
+    {
+        for (std::list<StaticInitializationHandler*>::iterator it = this->handlers_.begin(); it != this->handlers_.end(); ++it)
+            (*it)->unloadModule(module);
     }
 }

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

@@ -49 +49 @@
             void removeHandler(StaticInitializationHandler* handler);
 
+            void loadModule(ModuleInstance* module);
+            void unloadModule(ModuleInstance* module);
+
         private:
-            void addCoreHandler();
-
             std::list<StaticInitializationHandler*> handlers_;
     };