Changeset 10399

Timestamp:

Apr 26, 2015, 3:10:58 PM (10 years ago)

Author:

landauf

Message:

use typeid(T) instead of typeid(T).name() to identify a class. this avoids ambiguity if two classes in different anonymous namespaces use the same name.

Location:

code/branches/core7/src/libraries/core/class

Files:

• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (5 diffs)
• IdentifierManager.cc (modified) (6 diffs)
• IdentifierManager.h (modified) (3 diffs)

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

@@ -197 +197 @@
         {
             // only Identifiable is allowed to have no parents (even tough it's currently not abstract)
-            orxout(internal_error) << "Identifier " << this->getName() << " / " << this->getTypeidName() << " is marked as abstract but has no direct parents defined" << endl;
+            orxout(internal_error) << "Identifier " << this->getName() << " / " << this->getTypeInfo().name() << " is marked as abstract but has no direct parents defined" << endl;
             orxout(internal_error) << "  If this class is not abstract, use RegisterClass(ThisClass);" << endl;
             orxout(internal_error) << "  If this class is abstract, use RegisterAbstractClass(ThisClass).inheritsFrom(Class(BaseClass));" << endl;

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

@@ -117 +117 @@
             inline const std::string& getName() const { return this->name_; }
 
-            /// Returns the name of the class as it is returned by typeid(T).name()
-            virtual const std::string& getTypeidName() = 0;
+            /// Returns the type_info of the class as it is returned by typeid(T)
+            virtual const std::type_info& getTypeInfo() = 0;
 
             /// Returns the network ID to identify a class through the network.
@@ -265 +265 @@
                 ClassIdentifier<T>::classIdentifier_s = this;
 
-                this->typeidName_ = typeid(T).name();
                 SuperFunctionInitialization<0, T>::initialize(this);
             }
@@ -283 +282 @@
             virtual void updateConfigValues(bool updateChildren = true) const;
 
-            virtual const std::string& getTypeidName()
-                { return this->typeidName_; }
+            virtual const std::type_info& getTypeInfo()
+                { return typeid(T); }
 
             virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
@@ -297 +296 @@
             void updateConfigValues(bool updateChildren, Identifiable*) const;
 
-            std::string typeidName_;
             static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
     };
@@ -312 +310 @@
     {
         if (ClassIdentifier<T>::classIdentifier_s == NULL)
-            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeidName(typeid(T).name());
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeInfo(typeid(T));
 
         OrxVerify(ClassIdentifier<T>::classIdentifier_s != NULL, "Assertion failed in ClassIdentifier of type " << typeid(T).name());

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

@@ -62 +62 @@
     void IdentifierManager::addIdentifier(Identifier* identifier)
     {
-        orxout(verbose, context::identifier) << "Adding identifier for " << identifier->getName() << " / " << identifier->getTypeidName() << endl;
-
-        this->identifierByTypeidName_[identifier->getTypeidName()] = 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;
@@ -87 +87 @@
         {
             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);
+
+                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->identifierTraceOfNewObject_.clear();
-                    this->recordTraceForIdentifier_ = it->second;
-
-                    Identifiable* temp = it->second->fabricate(&temporaryContext);
+                    this->recordTraceForIdentifier_ = identifier;
+
+                    Identifiable* temp = identifier->fabricate(&temporaryContext);
 
                     this->recordTraceForIdentifier_ = NULL;
 
-                    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;
-
-                    it->second->initializeParents(this->identifierTraceOfNewObject_[temp]);
+                    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;
                 }
 
-                initializedIdentifiers.insert(it->second);
+                initializedIdentifiers.insert(identifier);
             }
 
@@ -117 +119 @@
 
         // 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();
+        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+        {
+            Identifier* identifier = (*it);
+
+            if (initializedIdentifiers.find(identifier) != initializedIdentifiers.end())
+                identifier->finishInitialization();
             else
-                orxout(internal_error) << "Identifier was registered late and is not initialized: " << it->second->getName() << " / " << it->second->getTypeidName() << endl;
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
         }
 
@@ -139 +143 @@
     {
         Context temporaryContext(NULL);
-        for (std::map<std::string, Identifier*>::const_iterator it1 = this->identifierByTypeidName_.begin(); it1 != this->identifierByTypeidName_.end(); ++it1)
-        {
-            if (!it1->second->hasFactory())
+        for (std::set<Identifier*>::const_iterator it1 = this->identifiers_.begin(); it1 != this->identifiers_.end(); ++it1)
+        {
+            if (!(*it1)->hasFactory())
                 continue;
 
-            Identifiable* temp = it1->second->fabricate(&temporaryContext);
-
-            for (std::map<std::string, Identifier*>::const_iterator it2 = this->identifierByTypeidName_.begin(); it2 != this->identifierByTypeidName_.end(); ++it2)
+            Identifiable* temp = (*it1)->fabricate(&temporaryContext);
+
+            for (std::set<Identifier*>::const_iterator it2 = this->identifiers_.begin(); it2 != this->identifiers_.end(); ++it2)
             {
-                bool isA_AccordingToRtti = it2->second->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA(it2->second);
+                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->second->getName() <<
-                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << it2->second->getName() << " but RTTI says the opposite." << endl;
+                    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;
                 }
             }
@@ -172 +176 @@
     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();
+        for (std::set<Identifier*>::iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            delete (*it);
+
+        this->identifiers_.clear();
         this->identifierByString_.clear();
         this->identifierByLowercaseString_.clear();
@@ -250 +254 @@
         @return The Identifier
     */
-    Identifier* IdentifierManager::getIdentifierByTypeidName(const std::string& typeidName)
-    {
-        std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.find(typeidName);
-        if (it != this->identifierByTypeidName_.end())
-            return it->second;
-        else
-            return 0;
+    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;
     }
 

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

@@ -38 +38 @@
 
 #include <map>
+#include <set>
 #include <list>
 #include <string>
@@ -74 +75 @@
             Identifier* getIdentifierByLowercaseString(const std::string& name);
             Identifier* getIdentifierByID(uint32_t id);
-            Identifier* getIdentifierByTypeidName(const std::string& typeidName);
+            Identifier* getIdentifierByTypeInfo(const std::type_info& typeInfo);
 
             void clearNetworkIDs();
@@ -100 +101 @@
                 { hierarchyCreatingCounter_s--; }
 
-            std::map<std::string, Identifier*> identifierByTypeidName_;      //!< Map with the names as received by typeid(). This is only used internally.
-
+            std::set<Identifier*> identifiers_;                              //!< All identifiers. This is only used internally.
             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.