Changeset 5877 for code/branches/core5/src/libraries/core

Timestamp:

Oct 5, 2009, 1:34:10 AM (15 years ago)

Author:

rgrieder

Message:

Added new an option for the ScopedSingletonManager that can allow the Singleton to fail (throw an exception).
Also improved exception-safety in Scope so that when for a Singleton fails, the Scope will deactivate all activated listeners and properly destroy itself.

Location:

code/branches/core5/src/libraries/core

Files:

• Core.cc (modified) (2 diffs)
• ScopedSingletonManager.h (modified) (6 diffs)
• input/KeyBinderManager.cc (modified) (1 diff)
• input/KeyDetector.cc (modified) (1 diff)

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

@@ -434 +434 @@
     {
         // singletons from other libraries
-        ScopedSingletonManager::update(time, ScopeID::Root);
+        ScopedSingletonManager::update<ScopeID::Root>(time);
         if (this->bGraphicsLoaded_)
         {
@@ -442 +442 @@
             this->guiManager_->update(time);
             // graphics singletons from other libraries
-            ScopedSingletonManager::update(time, ScopeID::Graphics);
+            ScopedSingletonManager::update<ScopeID::Graphics>(time);
         }
         // process thread commands

code/branches/core5/src/libraries/core/ScopedSingletonManager.h

@@ -34 +34 @@
 #include <cassert>
 #include <map>
+#include "util/Exception.h"
 #include "util/Scope.h"
 #include "util/Singleton.h"
 
-#define ManageScopedSingleton(className, scope) \
-    static ClassScopedSingletonManager<className, scope> className##ScopedSingletonManager(#className)
+#define ManageScopedSingleton(className, scope, allowedToFail) \
+    static ClassScopedSingletonManager<className, scope, allowedToFail> className##ScopedSingletonManager(#className)
 
 namespace orxonox
@@ -53 +54 @@
             static void removeManager(ScopedSingletonManager* manager);
 
-            static void update(const Clock& time, ScopeID::Value scope)
+            template<ScopeID::Value scope>
+            static void update(const Clock& time)
             {
+                assert(Scope<scope>::isActive());
                 for (ManagerMultiMap::iterator it = getManagersByScope().lower_bound(scope); it != getManagersByScope().upper_bound(scope); ++it)
                     it->second->update(time);
@@ -69 +72 @@
     };
 
-    template <class T, ScopeID::Value scope>
+    template <class T, ScopeID::Value scope, bool allowedToFail>
     class ClassScopedSingletonManager : public ScopedSingletonManager, public ScopeListener
     {
@@ -83 +86 @@
         ~ClassScopedSingletonManager()
         {
+            assert(singletonPtr_ == NULL);
             ScopedSingletonManager::removeManager(this);
         }
@@ -101 +105 @@
         }
 
+        void destroy(OrxonoxClass*)
+        {
+            singletonPtr_->destroy();
+        }
+        void destroy(void*)
+        {
+            delete singletonPtr_;
+        }
+
+        //! Called every frame by the ScopedSingletonManager
+        void update(const Clock& time)
+        {
+            assert(Scope<scope>::isActive());
+            // assuming T inherits Singleton<T>
+            singletonPtr_->updateSingleton(time);
+        }
+
+    private:
+        T* singletonPtr_;
+    };
+
+    template <class T, ScopeID::Value scope>
+    class ClassScopedSingletonManager<T, scope, true> : public ScopedSingletonManager, public ScopeListener
+    {
+    public:
+        ClassScopedSingletonManager(const std::string& className)
+            : ScopedSingletonManager(className, scope)
+            , ScopeListener(scope)
+            , singletonPtr_(NULL)
+        {
+            ScopedSingletonManager::addManager(this);
+        }
+
+        ~ClassScopedSingletonManager()
+        {
+            assert(singletonPtr_ == NULL);
+            ScopedSingletonManager::removeManager(this);
+        }
+
+        //! Called if the Scope of the Singleton gets active (creates the instance)
+        void activated()
+        {
+            assert(singletonPtr_ == NULL);
+            try
+                { singletonPtr_ = new T(); }
+            catch (...)
+                { COUT(1) << "Singleton creation failed: " << Exception::handleMessage() << std::endl; }
+        }
+
+        //! Called if the Scope of this Singleton gets deactivated (destroys the instance)
+        void deactivated()
+        {
+            if (singletonPtr_ != NULL)
+            {
+                this->destroy(singletonPtr_);
+                singletonPtr_ = NULL;
+            }
+        }
+
         void destroy(OrxonoxClass* ptr)
         {
@@ -113 +176 @@
         void update(const Clock& time)
         {
+            assert(Scope<scope>::isActive());
             // assuming T inherits Singleton<T>
-            singletonPtr_->updateSingleton(time);
+            if (singletonPtr_ != NULL)
+                singletonPtr_->updateSingleton(time);
         }
 

code/branches/core5/src/libraries/core/input/KeyBinderManager.cc

@@ -41 +41 @@
 {
     KeyBinderManager* KeyBinderManager::singletonPtr_s = 0;
-    ManageScopedSingleton(KeyBinderManager, ScopeID::Graphics);
+    ManageScopedSingleton(KeyBinderManager, ScopeID::Graphics, false);
 
     KeyBinderManager::KeyBinderManager()

code/branches/core5/src/libraries/core/input/KeyDetector.cc

@@ -40 +40 @@
     std::string KeyDetector::callbackCommand_s = "KeyDetectorKeyPressed";
     KeyDetector* KeyDetector::singletonPtr_s = 0;
-    ManageScopedSingleton(KeyDetector, ScopeID::Graphics);
+    ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
 
     KeyDetector::KeyDetector()