Changeset 10514 for code/branches/core7

Timestamp:

May 31, 2015, 10:22:59 AM (9 years ago)

Author:

landauf

Message:

don't store scope in ScopeListener - instead register the listener in ScopeManager for a specific scope

Location:

code/branches/core7/src/libraries/core/singleton

Files:

• Scope.h (modified) (2 diffs)
• ScopeManager.cc (modified) (1 diff)
• ScopeManager.h (modified) (1 diff)
• ScopedSingletonIncludes.cc (modified) (1 diff)
• ScopedSingletonIncludes.h (modified) (3 diffs)
• ScopedSingletonWrapper.h (modified) (5 diffs)

code/branches/core7/src/libraries/core/singleton/Scope.h

@@ -71 +71 @@
 
         protected:
-            ScopeListener(ScopeID::Value scope) : scope_(scope), bActivated_(false) { }
+            ScopeListener() : bActivated_(false) { }
             virtual ~ScopeListener() { }
 
@@ -79 +79 @@
             virtual void deactivated() = 0;
 
-        public:
-            inline ScopeID::Value getScope() const
-                { return this->scope_; }
-
         private:
-            ScopeID::Value scope_; //!< Store the scope to unregister on destruction
             bool bActivated_;
     };

code/branches/core7/src/libraries/core/singleton/ScopeManager.cc

@@ -61 +61 @@
     }
 
-    void ScopeManager::addListener(ScopeListener* listener)
+    void ScopeManager::addListener(ScopeListener* listener, ScopeID::Value scope)
     {
-        this->listeners_[listener->getScope()].insert(listener);
+        this->listeners_[scope].insert(listener);
     }
 
-    void ScopeManager::removeListener(ScopeListener* listener)
+    void ScopeManager::removeListener(ScopeListener* listener, ScopeID::Value scope)
     {
-        this->listeners_[listener->getScope()].erase(listener);
+        this->listeners_[scope].erase(listener);
     }
 

code/branches/core7/src/libraries/core/singleton/ScopeManager.h

@@ -65 +65 @@
 
             /** Registers a listener for the given scope. */
-            void addListener(ScopeListener* listener);
+            void addListener(ScopeListener* listener, ScopeID::Value scope);
             /** Unregisters a listener for the given scope. */
-            void removeListener(ScopeListener* listener);
+            void removeListener(ScopeListener* listener, ScopeID::Value scope);
 
         private:

code/branches/core7/src/libraries/core/singleton/ScopedSingletonIncludes.cc

@@ -33 +33 @@
     void StaticallyInitializedScopedSingletonWrapper::load()
     {
-        ScopeManager::getInstance().addListener(this->wrapper_);
+        ScopeManager::getInstance().addListener(this->wrapper_, this->scope_);
     }
 
     void StaticallyInitializedScopedSingletonWrapper::unload()
     {
-        ScopeManager::getInstance().removeListener(this->wrapper_);
+        ScopeManager::getInstance().removeListener(this->wrapper_, this->scope_);
     }
 }

code/branches/core7/src/libraries/core/singleton/ScopedSingletonIncludes.h

@@ -73 +73 @@
     className* className::singletonPtr_s = NULL; \
     static ScopedSingletonWrapper& className##ScopedSingletonWrapper \
-        = (new orxonox::SI_SSW(new ClassScopedSingletonWrapper<className, scope, allowedToFail>(#className)))->getWrapper()
+        = (new orxonox::SI_SSW(new ClassScopedSingletonWrapper<className, allowedToFail>(#className), scope))->getWrapper()
 
 namespace orxonox
@@ -80 +80 @@
     {
         public:
-            StaticallyInitializedScopedSingletonWrapper(ScopedSingletonWrapper* wrapper) : wrapper_(wrapper) {}
+            StaticallyInitializedScopedSingletonWrapper(ScopedSingletonWrapper* wrapper, ScopeID::Value scope)
+                : wrapper_(wrapper)
+                , scope_(scope)
+            {}
 
             virtual void load();
@@ -90 +93 @@
         private:
             ScopedSingletonWrapper* wrapper_;
+            ScopeID::Value scope_;
     };
 

code/branches/core7/src/libraries/core/singleton/ScopedSingletonWrapper.h

@@ -61 +61 @@
         public:
             /// Constructor: Initializes all the values
-            ScopedSingletonWrapper(const std::string& className, ScopeID::Value scope)
-                : ScopeListener(scope)
-                , className_(className)
+            ScopedSingletonWrapper(const std::string& className)
+                : className_(className)
             { }
             virtual ~ScopedSingletonWrapper() { }
@@ -74 +73 @@
         @anchor ClassScopedSingletonWrapper
 
-        @brief Manages a scoped singleton for a given scope.
+        @brief Manages a scoped singleton
         @param T The managed singleton class
-        @param scope The scope in which the singleton @a T should be active
         @param allowedToFail If true, a specialization of this template is used, that uses try-catch blocks to handle possible failures.
 
-        This class inherits from ScopeListener for the given scope and thus its functions
+        This class inherits from ScopeListener and is registered for a scope in ScopeManager and thus its functions
         activated() and deactivated() are called whenever the Scope changes its state.
 
@@ -87 +85 @@
         @see Singleton
     */
-    template <class T, ScopeID::Value scope, bool allowedToFail>
+    template <class T, bool allowedToFail>
     class ClassScopedSingletonWrapper : public ScopedSingletonWrapper
     {
     public:
-        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonWrapper and ScopeListener
         ClassScopedSingletonWrapper(const std::string& className)
-            : ScopedSingletonWrapper(className, scope)
+            : ScopedSingletonWrapper(className)
             , singletonPtr_(NULL)
         {
@@ -135 +132 @@
         @brief This class partially spezializes ClassScopedSingletonWrapper for classes @a T that are allowed to fail.
         @param T The managed singleton class
-        @param scope The scope in which the singleton @a T should be active
 
         Because @a T could fail when being created, this partial spezialization of ClassScopedSingletonWrapper
@@ -142 +138 @@
         See @ref ClassScopedSingletonWrapper for a full documentation of the basis template.
     */
-    template <class T, ScopeID::Value scope>
-    class ClassScopedSingletonWrapper<T, scope, true> : public ScopedSingletonWrapper
+    template <class T>
+    class ClassScopedSingletonWrapper<T, true> : public ScopedSingletonWrapper
     {
     public:
-        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonWrapper and ScopeListener
         ClassScopedSingletonWrapper(const std::string& className)
-            : ScopedSingletonWrapper(className, scope)
+            : ScopedSingletonWrapper(className)
             , singletonPtr_(NULL)
         {