Changeset 9640 for code/branches/core6/src

Timestamp:

Aug 11, 2013, 9:07:38 PM (11 years ago)

Author:

landauf

Message:

made IdentifierManager a self-initializing singleton

Location:

code/branches/core6/src/libraries

Files:

• core/Core.cc (modified) (2 diffs)
• core/CoreIncludes.h (modified) (3 diffs)
• core/Template.cc (modified) (1 diff)
• core/XMLPort.cc (modified) (2 diffs)
• core/class/Identifier.cc (modified) (4 diffs)
• core/class/Identifier.h (modified) (2 diffs)
• core/class/IdentifierManager.cc (modified) (10 diffs)
• core/class/IdentifierManager.h (modified) (2 diffs)
• core/config/ConfigValueContainer.h (modified) (1 diff)
• network/packet/ClassID.cc (modified) (2 diffs)
• network/synchronisable/Synchronisable.cc (modified) (1 diff)

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

@@ -198 +198 @@
         // creates the class hierarchy for all classes with factories
         orxout(internal_info) << "creating class hierarchy" << endl;
-        IdentifierManager::createClassHierarchy();
+        IdentifierManager::getInstance().createClassHierarchy();
 
         // Load OGRE excluding the renderer and the render window
@@ -248 +248 @@
         safeObjectDelete(&configFileManager_);
         ConsoleCommand::destroyAll();
-        IdentifierManager::destroyAllIdentifiers();
+        IdentifierManager::getInstance().destroyAllIdentifiers();
         safeObjectDelete(&signalHandler_);
         safeObjectDelete(&dynLibManager_);

code/branches/core6/src/libraries/core/CoreIncludes.h

@@ -179 +179 @@
     inline Identifier* ClassByString(const std::string& name)
     {
-        return IdentifierManager::getIdentifierByString(name);
+        return IdentifierManager::getInstance().getIdentifierByString(name);
     }
 
@@ -188 +188 @@
     inline Identifier* ClassByLowercaseString(const std::string& name)
     {
-        return IdentifierManager::getIdentifierByLowercaseString(name);
+        return IdentifierManager::getInstance().getIdentifierByLowercaseString(name);
     }
 
@@ -197 +197 @@
     inline Identifier* ClassByID(uint32_t id)
     {
-        return IdentifierManager::getIdentifierByID(id);
+        return IdentifierManager::getInstance().getIdentifierByID(id);
     }
 

code/branches/core6/src/libraries/core/Template.cc

@@ -150 +150 @@
 
         // check if the template is applied on an object of the right type
-        Identifier* identifier = IdentifierManager::getIdentifierByString(this->getXMLElement().Value());
+        Identifier* identifier = ClassByString(this->getXMLElement().Value());
         if (!object->getIdentifier()->isA(identifier))
             orxout(internal_warning, context::templates) << "Template was defined for " << identifier->getName() << " but the object is of type " << object->getIdentifier()->getName() << endl;

code/branches/core6/src/libraries/core/XMLPort.cc

@@ -29 +29 @@
 #include "XMLPort.h"
 
+#include "CoreIncludes.h"
 #include "Loader.h"
 #include "Namespace.h"
@@ -59 +60 @@
                 for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
                 {
-                    Identifier* identifier = IdentifierManager::getIdentifierByString(child->Value());
+                    Identifier* identifier = ClassByString(child->Value());
                     if (!identifier)
                     {

code/branches/core6/src/libraries/core/class/Identifier.cc

@@ -50 +50 @@
     */
     Identifier::Identifier()
-        : classID_(IdentifierManager::classIDCounter_s++)
+        : classID_(IdentifierManager::getInstance().classIDCounter_s++)
     {
         this->bCreatedOneObject_ = false;
@@ -87 +87 @@
     {
         // Check if at least one object of the given type was created
-        if (!this->bCreatedOneObject_ && IdentifierManager::isCreatingHierarchy())
+        if (!this->bCreatedOneObject_ && IdentifierManager::getInstance().isCreatingHierarchy())
         {
             // If no: We have to store the information and initialize the Identifier
@@ -155 +155 @@
             this->name_ = name;
             this->bSetName_ = true;
-            IdentifierManager::getStringIdentifierMapIntern()[name] = this;
-            IdentifierManager::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
-            IdentifierManager::getIDIdentifierMapIntern()[this->networkID_] = this;
+            IdentifierManager::getInstance().identifierByString_[name] = this;
+            IdentifierManager::getInstance().identifierByLowercaseString_[getLowercase(name)] = this;
+            IdentifierManager::getInstance().identifierByNetworkId_[this->networkID_] = this;
         }
     }
@@ -196 +196 @@
     {
 //        Identifier::getIDIdentifierMapIntern().erase(this->networkID_);
-        IdentifierManager::getIDIdentifierMapIntern()[id] = this;
+        IdentifierManager::getInstance().identifierByNetworkId_[id] = this;
         this->networkID_ = id;
     }

code/branches/core6/src/libraries/core/class/Identifier.h

@@ -346 +346 @@
 
         // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getIdentifierSingleton(name, proposal);
+        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getInstance().getIdentifierSingleton(name, proposal);
 
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
@@ -373 +373 @@
 
         object->identifier_ = this;
-        if (IdentifierManager::isCreatingHierarchy())
+        if (IdentifierManager::getInstance().isCreatingHierarchy())
         {
             if (bRootClass && !object->parents_)

code/branches/core6/src/libraries/core/class/IdentifierManager.cc

@@ -43 +43 @@
 namespace orxonox
 {
-    int IdentifierManager::hierarchyCreatingCounter_s = 0;
-    unsigned int IdentifierManager::classIDCounter_s = 0;
+    /* static */ IdentifierManager& IdentifierManager::getInstance()
+    {
+        static IdentifierManager instance;
+        return instance;
+    }
 
-    /**
-        @brief Returns the identifier map with the names as received by typeid(). This is only used internally.
-    */
-    std::map<std::string, Identifier*>& IdentifierManager::getTypeIDIdentifierMap()
+    IdentifierManager::IdentifierManager()
     {
-        static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
-        return identifiers;
+        this->hierarchyCreatingCounter_s = 0;
+        this->classIDCounter_s = 0;
     }
 
@@ -63 +63 @@
     Identifier* IdentifierManager::getIdentifierSingleton(const std::string& name, Identifier* proposal)
     {
-        std::map<std::string, Identifier*>::const_iterator it = getTypeIDIdentifierMap().find(name);
+        std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeId_.find(name);
 
-        if (it != getTypeIDIdentifierMap().end())
+        if (it != this->identifierByTypeId_.end())
         {
             // There is already an entry: return it and delete the proposal
@@ -74 +74 @@
         {
             // There is no entry: put the proposal into the map and return it
-            getTypeIDIdentifierMap()[name] = proposal;
+            this->identifierByTypeId_[name] = proposal;
             return proposal;
         }
@@ -85 +85 @@
     {
         orxout(internal_status) << "Create class-hierarchy" << endl;
-        IdentifierManager::startCreatingHierarchy();
-        for (std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getTypeIDIdentifierMap().begin(); it != IdentifierManager::getTypeIDIdentifierMap().end(); ++it)
+        this->startCreatingHierarchy();
+        for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeId_.begin(); it != this->identifierByTypeId_.end(); ++it)
         {
             // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
@@ -95 +95 @@
             }
         }
-        IdentifierManager::stopCreatingHierarchy();
+        this->stopCreatingHierarchy();
         orxout(internal_status) << "Finished class-hierarchy creation" << endl;
     }
@@ -104 +104 @@
     void IdentifierManager::destroyAllIdentifiers()
     {
-        for (std::map<std::string, Identifier*>::iterator it = IdentifierManager::getTypeIDIdentifierMap().begin(); it != IdentifierManager::getTypeIDIdentifierMap().end(); ++it)
+        for (std::map<std::string, Identifier*>::iterator it = this->identifierByTypeId_.begin(); it != this->identifierByTypeId_.end(); ++it)
             delete (it->second);
 
-        IdentifierManager::getTypeIDIdentifierMap().clear();
-        IdentifierManager::getStringIdentifierMapIntern().clear();
-        IdentifierManager::getLowercaseStringIdentifierMapIntern().clear();
-        IdentifierManager::getIDIdentifierMapIntern().clear();
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their names.
-        @return The map
-    */
-    std::map<std::string, Identifier*>& IdentifierManager::getStringIdentifierMapIntern()
-    {
-        static std::map<std::string, Identifier*> identifierMap;
-        return identifierMap;
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their names in lowercase.
-        @return The map
-    */
-    std::map<std::string, Identifier*>& IdentifierManager::getLowercaseStringIdentifierMapIntern()
-    {
-        static std::map<std::string, Identifier*> lowercaseIdentifierMap;
-        return lowercaseIdentifierMap;
-    }
-
-    /**
-        @brief Returns the map that stores all Identifiers with their network IDs.
-        @return The map
-    */
-    std::map<uint32_t, Identifier*>& IdentifierManager::getIDIdentifierMapIntern()
-    {
-        static std::map<uint32_t, Identifier*> identifierMap;
-        return identifierMap;
+        this->identifierByTypeId_.clear();
+        this->identifierByString_.clear();
+        this->identifierByLowercaseString_.clear();
+        this->identifierByNetworkId_.clear();
     }
 
@@ -150 +120 @@
     Identifier* IdentifierManager::getIdentifierByString(const std::string& name)
     {
-        std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getStringIdentifierMapIntern().find(name);
-        if (it != IdentifierManager::getStringIdentifierMapIntern().end())
+        std::map<std::string, Identifier*>::const_iterator it = this->identifierByString_.find(name);
+        if (it != this->identifierByString_.end())
             return it->second;
         else
@@ -164 +134 @@
     Identifier* IdentifierManager::getIdentifierByLowercaseString(const std::string& name)
     {
-        std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getLowercaseStringIdentifierMapIntern().find(name);
-        if (it != IdentifierManager::getLowercaseStringIdentifierMapIntern().end())
+        std::map<std::string, Identifier*>::const_iterator it = this->identifierByLowercaseString_.find(name);
+        if (it != this->identifierByLowercaseString_.end())
             return it->second;
         else
@@ -178 +148 @@
     Identifier* IdentifierManager::getIdentifierByID(const uint32_t id)
     {
-        std::map<uint32_t, Identifier*>::const_iterator it = IdentifierManager::getIDIdentifierMapIntern().find(id);
-        if (it != IdentifierManager::getIDIdentifierMapIntern().end())
+        std::map<uint32_t, Identifier*>::const_iterator it = this->identifierByNetworkId_.find(id);
+        if (it != this->identifierByNetworkId_.end())
             return it->second;
         else
@@ -190 +160 @@
     void IdentifierManager::clearNetworkIDs()
     {
-        IdentifierManager::getIDIdentifierMapIntern().clear();
+        this->identifierByNetworkId_.clear();
     }
 }

code/branches/core6/src/libraries/core/class/IdentifierManager.h

@@ -48 +48 @@
 
         public:
+            static IdentifierManager& getInstance();
+
             /////////////////////////////
             ////// Class Hierarchy //////
             /////////////////////////////
-            static void createClassHierarchy();
+            void createClassHierarchy();
 
             /// Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents.
-            inline static bool isCreatingHierarchy()
+            inline bool isCreatingHierarchy()
                 { return (hierarchyCreatingCounter_s > 0); }
 
@@ -61 +63 @@
             ///// Identifier Map /////
             //////////////////////////
-            static void destroyAllIdentifiers();
+            void destroyAllIdentifiers();
 
-            static Identifier* getIdentifierByString(const std::string& name);
-            static Identifier* getIdentifierByLowercaseString(const std::string& name);
-            static Identifier* getIdentifierByID(uint32_t id);
+            Identifier* getIdentifierByString(const std::string& name);
+            Identifier* getIdentifierByLowercaseString(const std::string& name);
+            Identifier* getIdentifierByID(uint32_t id);
 
-            static void clearNetworkIDs();
+            void clearNetworkIDs();
 
             /// Returns the map that stores all Identifiers with their names.
-            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap()
-                { return IdentifierManager::getStringIdentifierMapIntern(); }
+            inline const std::map<std::string, Identifier*>& getStringIdentifierMap()
+                { return this->identifierByString_; }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin()
-                { return IdentifierManager::getStringIdentifierMap().begin(); }
+            inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin()
+                { return this->identifierByString_.begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their names.
-            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd()
-                { return IdentifierManager::getStringIdentifierMap().end(); }
+            inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd()
+                { return this->identifierByString_.end(); }
 
             /// Returns the map that stores all Identifiers with their names in lowercase.
-            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap()
-                { return IdentifierManager::getLowercaseStringIdentifierMapIntern(); }
+            inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap()
+                { return this->identifierByLowercaseString_; }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin()
-                { return IdentifierManager::getLowercaseStringIdentifierMap().begin(); }
+            inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin()
+                { return this->identifierByLowercaseString_.begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase.
-            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd()
-                { return IdentifierManager::getLowercaseStringIdentifierMap().end(); }
+            inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd()
+                { return this->identifierByLowercaseString_.end(); }
 
             /// Returns the map that stores all Identifiers with their IDs.
-            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap()
-                { return IdentifierManager::getIDIdentifierMapIntern(); }
+            inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap()
+                { return this->identifierByNetworkId_; }
             /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin()
-                { return IdentifierManager::getIDIdentifierMap().begin(); }
+            inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin()
+                { return this->identifierByNetworkId_.begin(); }
             /// Returns a const_iterator to the end of the map that stores all Identifiers with their IDs.
-            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd()
-                { return IdentifierManager::getIDIdentifierMap().end(); }
+            inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd()
+                { return this->identifierByNetworkId_.end(); }
 
         protected:
-            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
-
-            /// Returns the map that stores all Identifiers with their names.
-            static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
-            /// Returns the map that stores all Identifiers with their names in lowercase.
-            static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
-            /// Returns the map that stores all Identifiers with their network IDs.
-            static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
+            Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
 
         private:
+            IdentifierManager();
+            IdentifierManager(const IdentifierManager&);
+            ~IdentifierManager() {}
+
             /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
-            inline static void startCreatingHierarchy()
+            inline void startCreatingHierarchy()
                 { hierarchyCreatingCounter_s++; }
             /// Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
-            inline static void stopCreatingHierarchy()
+            inline void stopCreatingHierarchy()
                 { hierarchyCreatingCounter_s--; }
 
-            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
+            std::map<std::string, Identifier*> identifierByTypeId_;          //!< Map with the names as received by typeid(). This is only used internally.
 
-            static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
-            static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
+            std::map<std::string, Identifier*> identifierByString_;          //!< Map that stores all Identifiers with their names.
+            std::map<std::string, Identifier*> identifierByLowercaseString_; //!< Map that stores all Identifiers with their names in lowercase.
+            std::map<uint32_t, Identifier*> identifierByNetworkId_;          //!< Returns the map that stores all Identifiers with their network IDs.
+
+            int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
+            unsigned int classIDCounter_s;                          //!< counter for the unique classIDs
     };
 }

code/branches/core6/src/libraries/core/config/ConfigValueContainer.h

@@ -70 +70 @@
             inline virtual void call(void* object)
             {
-                if (!IdentifierManager::isCreatingHierarchy())
+                if (!IdentifierManager::getInstance().isCreatingHierarchy())
                     (static_cast<T*>(object)->*this->function_)();
             }

code/branches/core6/src/libraries/network/packet/ClassID.cc

@@ -55 +55 @@
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getStringIdentifierMapBegin();
-  for(;it != IdentifierManager::getStringIdentifierMapEnd();++it){
+  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getInstance().getStringIdentifierMapBegin();
+  for(;it != IdentifierManager::getInstance().getStringIdentifierMapEnd();++it){
     id = it->second;
     if(id == NULL || !id->hasFactory())
@@ -129 +129 @@
 
   //clear the map of network ids
-  IdentifierManager::clearNetworkIDs();
+  IdentifierManager::getInstance().clearNetworkIDs();
 
   orxout(verbose, context::packets) << "=== processing classids: " << endl;

code/branches/core6/src/libraries/network/synchronisable/Synchronisable.cc

@@ -80 +80 @@
   {
     // delete callback function objects
-    if(!IdentifierManager::isCreatingHierarchy()){
+    if(!IdentifierManager::getInstance().isCreatingHierarchy()){
       // remove object from the static objectMap
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))