Changeset 10458 for code/branches/core7/src/libraries/core/singleton

Timestamp:

May 24, 2015, 11:51:05 AM (10 years ago)

Author:

landauf

Message:

renamed ScopedSingletonManager to ScopedSingletonWrapper. removed static maps.

Location:

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

Files:

• CMakeLists.txt (modified) (1 diff)
• Scope.h (modified) (1 diff)
• ScopedSingletonManager.cc (deleted)
• ScopedSingletonWrapper.h (moved) (moved from code/branches/core7/src/libraries/core/singleton/ScopedSingletonManager.h) (9 diffs)

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

@@ -1 +1 @@
 ADD_SOURCE_FILES(CORE_SRC_FILES
   Scope.cc
-  ScopedSingletonManager.cc
 )

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

@@ -46 +46 @@
 Scopes are usually used to control the creation and destruction of Singletons.
 
-@see orxonox::ScopedSingletonManager
 @see orxonox::Singleton
 */

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

@@ -30 +30 @@
     @file
     @ingroup SingletonScope
-    @brief Definition of orxonox::ScopedSingletonManager, orxonox::ClassScopedSingletonManager, and the ManageScopedSingleton macro.
-
-    ScopedSingletonManager is used to create and destroy Singletons that belong to
+    @brief Definition of orxonox::ScopedSingletonWrapper, orxonox::ClassScopedSingletonWrapper, and the ManageScopedSingleton macro.
+
+    ScopedSingletonWrapper is used to create and destroy Singletons that belong to
     a given Scope. For each one of these singletons, the macro ManageScopedSingleton()
-    has to be called to register the singleton with orxonox::ScopedSingletonManager.
+    has to be called to register the wrapper with orxonox::ScopeManager.
 
     See @ref SingletonExample "this code" for an example.
@@ -42 +42 @@
 */
 
-#ifndef __ScopedSingletonManager_H__
-#define __ScopedSingletonManager_H__
+#ifndef __ScopedSingletonWrapper_H__
+#define __ScopedSingletonWrapper_H__
 
 #include "core/CorePrereqs.h"
 
 #include <cassert>
-#include <map>
 #include "util/Exception.h"
 #include "util/Singleton.h"
@@ -54 +53 @@
 
 /**
-    @brief Registers an orxonox::Singleton with orxonox::ScopedSingletonManager.
+    @brief Creates an orxonox::ScopedSingletonWrapper for an orxonox::Singleton and registers it with orxonox::ScopeManager.
     @param className The name of the singleton class
     @param scope The scope in which the singleton should exist
     @param allowedToFail If true, the singleton is allowed to fail and thus a try-catch block is used when creating the singleton.
 
-    If this macro is called for a singleton, it is registered with ScopedSingletonManager
+    If this macro is called for a singleton, it is wrapped in a ScopedSingletonWrapper and registered with ScopeManager
     and will thus be created if its scope becomes active and destroyed if is deactivated.
 
@@ -66 +65 @@
     be destroyed (unless the singleton explicitly deletes itself). To allow controlled
     construction and destruction, the singleton can be put within a virtual scope. This is
-    done by registering the singleton class with orxonox::ScopedSingletonManager. To
+    done by registering the singleton class with orxonox::ScopeManager. To
     do so, the ManageScopedSingleton() macro has to be called:
 
@@ -84 +83 @@
 #define ManageScopedSingleton(className, scope, allowedToFail) \
     className* className::singletonPtr_s = NULL; \
-    static ClassScopedSingletonManager<className, scope, allowedToFail> className##ScopedSingletonManager(#className)
+    static ClassScopedSingletonWrapper<className, scope, allowedToFail> className##ScopedSingletonWrapper(#className)
 
 namespace orxonox
 {
     /**
-        @brief Base class of ClassScopedSingletonManager. Keeps track of all existing ScopedSingletonManagers
-        and stores them in a map, sorted by the scope they belong to.
+        @brief Base class of ClassScopedSingletonWrapper.
     */
-    class _CoreExport ScopedSingletonManager
+    class _CoreExport ScopedSingletonWrapper
     {
         public:
             /// Constructor: Initializes all the values
-            ScopedSingletonManager(const std::string& className, ScopeID::Value scope)
+            ScopedSingletonWrapper(const std::string& className, ScopeID::Value scope)
                 : className_(className)
                 , scope_(scope)
             { }
-            virtual ~ScopedSingletonManager() { }
-
-            /// Adds a new instance of ScopedSingletonManager to the map.
-            static void addManager(ScopedSingletonManager* manager);
-
-            static std::map<std::string, ScopedSingletonManager*>& getManagers();
-            typedef std::multimap<ScopeID::Value, ScopedSingletonManager*> ManagerMultiMap;
+            virtual ~ScopedSingletonWrapper() { }
 
         protected:
@@ -114 +106 @@
 
     /**
-        @anchor ClassScopedSingletonManager
+        @anchor ClassScopedSingletonWrapper
 
         @brief Manages a scoped singleton for a given scope.
@@ -130 +122 @@
     */
     template <class T, ScopeID::Value scope, bool allowedToFail>
-    class ClassScopedSingletonManager : public ScopedSingletonManager, public ScopeListener
+    class ClassScopedSingletonWrapper : public ScopedSingletonWrapper, public ScopeListener
     {
     public:
-        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
-        ClassScopedSingletonManager(const std::string& className)
-            : ScopedSingletonManager(className, scope)
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonWrapper and ScopeListener
+        ClassScopedSingletonWrapper(const std::string& className)
+            : ScopedSingletonWrapper(className, scope)
             , ScopeListener(scope)
             , singletonPtr_(NULL)
         {
-            ScopedSingletonManager::addManager(this);
-        }
-
-        ~ClassScopedSingletonManager()
+        }
+
+        ~ClassScopedSingletonWrapper()
         {
         }
@@ -177 +168 @@
 
     /**
-        @brief This class partially spezializes ClassScopedSingletonManager for classes @a T that are allowed to fail.
+        @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 ClassScopedSingletonManager
+        Because @a T could fail when being created, this partial spezialization of ClassScopedSingletonWrapper
         uses a try-catch block to handle exceptions.
 
-        See @ref ClassScopedSingletonManager for a full documentation of the basis template.
+        See @ref ClassScopedSingletonWrapper for a full documentation of the basis template.
     */
     template <class T, ScopeID::Value scope>
-    class ClassScopedSingletonManager<T, scope, true> : public ScopedSingletonManager, public ScopeListener
+    class ClassScopedSingletonWrapper<T, scope, true> : public ScopedSingletonWrapper, public ScopeListener
     {
     public:
-        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
-        ClassScopedSingletonManager(const std::string& className)
-            : ScopedSingletonManager(className, scope)
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonWrapper and ScopeListener
+        ClassScopedSingletonWrapper(const std::string& className)
+            : ScopedSingletonWrapper(className, scope)
             , ScopeListener(scope)
             , singletonPtr_(NULL)
         {
-            ScopedSingletonManager::addManager(this);
-        }
-
-        ~ClassScopedSingletonManager()
+        }
+
+        ~ClassScopedSingletonWrapper()
         {
         }
@@ -241 +231 @@
 }
 
-#endif /* __ScopedSingletonManager_H__ */
+#endif /* __ScopedSingletonWrapper_H__ */