Changeset 10624 for code/trunk/src/libraries/core/class/IdentifierManager.cc

Timestamp:

Oct 4, 2015, 9:12:21 PM (10 years ago)

Author:

landauf

Message:

merged branch core7 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/class/IdentifierManager.cc (modified) (8 diffs)

code/trunk/src/libraries/core/class/IdentifierManager.cc

@@ -37 +37 @@
 
 #include "util/StringUtils.h"
-#include "core/CoreIncludes.h"
+#include "core/Core.h"
 #include "core/config/ConfigValueContainer.h"
 #include "core/XMLPort.h"
@@ -44 +44 @@
 namespace orxonox
 {
-    /* static */ IdentifierManager& IdentifierManager::getInstance()
-    {
-        static IdentifierManager instance;
-        return instance;
-    }
+    IdentifierManager* IdentifierManager::singletonPtr_s = 0;
 
     IdentifierManager::IdentifierManager()
     {
         this->hierarchyCreatingCounter_s = 0;
-        this->classIDCounter_s = 0;
-    }
-
-    /**
-        @brief Returns an identifier by name and adds it if not available
-        @param proposal A pointer to a newly created identifier for the case of non existence in the map
-        @return The identifier (unique instance)
-    */
-    Identifier* IdentifierManager::getGloballyUniqueIdentifier(Identifier* proposal)
-    {
-        const std::string& typeidName = proposal->getTypeidName();
-        std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.find(typeidName);
-
-        if (it != this->identifierByTypeidName_.end())
-        {
-            // There is already an entry: return it
-            return it->second;
-        }
-        else
-        {
-            // There is no entry: put the proposal into the map and return it
-            this->identifierByTypeidName_[typeidName] = proposal;
-            return proposal;
-        }
+        this->recordTraceForIdentifier_ = NULL;
     }
 
@@ -82 +55 @@
      * Registers the identifier in all maps of the IdentifierManager.
      */
-    void IdentifierManager::addIdentifierToLookupMaps(Identifier* identifier)
-    {
-        const std::string& typeidName = identifier->getTypeidName();
-        if (this->identifierByTypeidName_.find(typeidName) != this->identifierByTypeidName_.end())
-        {
-            this->identifierByString_[identifier->getName()] = identifier;
-            this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
-            this->identifierByNetworkId_[identifier->getNetworkID()] = identifier;
-        }
-        else
-            orxout(internal_warning) << "Trying to add an identifier to lookup maps which is not known to IdentifierManager" << endl;
+    void IdentifierManager::addIdentifier(Identifier* identifier)
+    {
+        orxout(verbose, context::identifier) << "Adding identifier for " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
+
+        this->identifiers_.insert(identifier);
+        this->identifierByString_[identifier->getName()] = identifier;
+        this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
+        this->identifierByNetworkId_[identifier->getNetworkID()] = identifier;
+    }
+
+    /**
+     * Unregisters the identifier from all maps of the IdentifierManager.
+     */
+    void IdentifierManager::removeIdentifier(Identifier* identifier)
+    {
+        this->identifiers_.erase(identifier);
+        this->identifierByString_.erase(identifier->getName());
+        this->identifierByLowercaseString_.erase(getLowercase(identifier->getName()));
+        this->identifierByNetworkId_.erase(identifier->getNetworkID());
     }
 
@@ -112 +93 @@
         {
             Context temporaryContext(NULL);
-            for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
+            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
             {
-                orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << it->second->getName() << ">-Singleton." << endl;
+                Identifier* identifier = (*it);
+                if (identifier->isInitialized())
+                    continue;
+
+                orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << identifier->getName() << ">-Singleton." << endl;
                 // To initialize the identifier, we create a new object and delete it afterwards.
-                if (it->second->hasFactory())
+                if (identifier->hasFactory())
                 {
-                    this->identifiersOfNewObject_.clear();
-                    Identifiable* temp = it->second->fabricate(&temporaryContext);
-                    if (temp->getIdentifier() != it->second)
-                        orxout(internal_error) << "Newly created object of type " << it->second->getName() << " has unexpected identifier. Did you forget to use RegisterObject(classname)?" << endl;
+                    this->identifierTraceOfNewObject_.clear();
+                    this->recordTraceForIdentifier_ = identifier;
+
+                    Identifiable* temp = identifier->fabricate(&temporaryContext);
+
+                    this->recordTraceForIdentifier_ = NULL;
+
+                    if (temp->getIdentifier() != identifier)
+                        orxout(internal_error) << "Newly created object of type " << identifier->getName() << " has unexpected identifier. Did you forget to use RegisterObject(classname)?" << endl;
+
+                    identifier->initializeParents(this->identifierTraceOfNewObject_[temp]);
+
                     delete temp;
-
-                    it->second->initializeParents(this->identifiersOfNewObject_);
                 }
-                else
-                    it->second->initializeDirectParentsOfAbstractClass();
-
-                initializedIdentifiers.insert(it->second);
+
+                initializedIdentifiers.insert(identifier);
             }
 
@@ -138 +127 @@
 
         // finish the initialization of all identifiers
-        for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
-        {
-            if (initializedIdentifiers.find(it->second) != initializedIdentifiers.end())
-                it->second->finishInitialization();
-            else
-                orxout(internal_error) << "Identifier was registered late and is not initialized: " << it->second->getName() << " / " << it->second->getTypeidName() << endl;
-        }
+        for (std::set<Identifier*>::const_iterator it = initializedIdentifiers.begin(); it != initializedIdentifiers.end(); ++it)
+            (*it)->finishInitialization();
+
+        // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
+        if (!Core::exists() || Core::getInstance().getConfig()->inDevMode())
+            this->verifyClassHierarchy(initializedIdentifiers);
 
         this->stopCreatingHierarchy();
@@ -151 +139 @@
 
     /**
-        @brief Destroys all Identifiers. Called when exiting the program.
-    */
-    void IdentifierManager::destroyAllIdentifiers()
-    {
-        for (std::map<std::string, Identifier*>::iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
-            delete (it->second);
-
-        this->identifierByTypeidName_.clear();
-        this->identifierByString_.clear();
-        this->identifierByLowercaseString_.clear();
-        this->identifierByNetworkId_.clear();
+     * Verifies if the class hierarchy is consistent with the RTTI.
+     */
+    void IdentifierManager::verifyClassHierarchy(const std::set<Identifier*>& initializedIdentifiers)
+    {
+        // check if there are any uninitialized identifiers remaining
+        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            if (!(*it)->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (*it)->getName() << " / " << (*it)->getTypeInfo().name() << endl;
+
+        // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
+        Context temporaryContext(NULL);
+        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
+        {
+            if (!(*it1)->hasFactory())
+                continue;
+
+            Identifiable* temp = (*it1)->fabricate(&temporaryContext);
+
+            for (std::set<Identifier*>::const_iterator it2 = this->identifiers_.begin(); it2 != this->identifiers_.end(); ++it2)
+            {
+                bool isA_AccordingToRtti = (*it2)->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA((*it2));
+
+                if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
+                {
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (*it1)->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (*it2)->getName() << " but RTTI says the opposite." << endl;
+                }
+            }
+
+            delete temp;
+        }
+        orxout(internal_info) << "Class hierarchy matches RTTI" << endl;
+
+        size_t numberOfObjects = temporaryContext.getObjectList<Listable>()->size();
+        if (numberOfObjects > 0)
+            orxout(internal_warning) << "There are still " << numberOfObjects << " listables left after creating the class hierarchy" << endl;
+    }
+
+    /**
+     * @brief Resets all Identifiers.
+     */
+    void IdentifierManager::destroyClassHierarchy()
+    {
+        orxout(internal_status) << "Destroy class-hierarchy" << endl;
+        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            (*it)->reset();
     }
 
@@ -170 +194 @@
     {
         if (this->isCreatingHierarchy())
-            this->identifiersOfNewObject_.insert(identifiable->getIdentifier());
+        {
+            if (this->recordTraceForIdentifier_)
+            {
+                std::list<const Identifier*>& traceForObject = this->identifierTraceOfNewObject_[identifiable];
+                if (std::find(traceForObject.begin(), traceForObject.end(), identifiable->getIdentifier()) != traceForObject.end())
+                {
+                    orxout(internal_warning) << this->recordTraceForIdentifier_->getName() << " inherits two times from " <<
+                        identifiable->getIdentifier()->getName() << ". Did you forget to use virtual inheritance?" << endl;
+                }
+                traceForObject.push_back(identifiable->getIdentifier());
+            }
+        }
         else
             orxout(internal_warning) << "createdObject() called outside of class hierarchy creation" << endl;
@@ -218 +253 @@
 
     /**
+        @brief Returns the Identifier with a given typeid-name.
+        @param name The typeid-name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* IdentifierManager::getIdentifierByTypeInfo(const std::type_info& typeInfo)
+    {
+        // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
+        for (std::set<Identifier*>::iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            if ((*it)->getTypeInfo() == typeInfo)
+                return (*it);
+        return 0;
+    }
+
+    /**
         @brief Cleans the NetworkID map (needed on clients for correct initialization)
     */