Changeset 10366

Timestamp:

Apr 15, 2015, 10:11:15 PM (10 years ago)

Author:

landauf

Message:

found a better solution to find identifiers that don't belong to the parents of a newly created instance.

Location:

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

Files:

• Identifier.cc (modified) (2 diffs)
• Identifier.h (modified) (1 diff)
• IdentifierManager.cc (modified) (2 diffs)
• IdentifierManager.h (modified) (1 diff)

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

@@ -144 +144 @@
     /**
      * @brief Initializes the parents of this Identifier while creating the class hierarchy.
-     * @param instance The instance that was used to determine the class hierarchy of this identifier.
-     * @param identifiers All identifiers that were used to create the instance of this class (including this identifier itself)
+     * @param initializationTrace All identifiers that were recorded while creating an instance of this class (including nested classes and this identifier itself)
      */
-    void Identifier::initializeParents(Identifiable* instance, const std::set<const Identifier*>& identifiers)
+    void Identifier::initializeParents(const std::set<const Identifier*>& initializationTrace)
     {
         if (!IdentifierManager::getInstance().isCreatingHierarchy())
@@ -155 +154 @@
         }
 
-        // Add all identifiers which are real parents (dynamic_cast is possible) and that are not equal to THIS identifier.
-        // Checking for dynamic_cast is necessary because some classes may have other classes as nested members. This means that the Identifiers of the nested
-        // classes are also added to the set of potential parents. The only way to distinguish them is to use RTTI (i.e. dynamic_cast).
-        for (std::set<const Identifier*>::const_iterator it = identifiers.begin(); it != identifiers.end(); ++it)
-            if (*it != this && (*it)->canDynamicCastObjectToIdentifierClass(instance))
+        for (std::set<const Identifier*>::const_iterator it = initializationTrace.begin(); it != initializationTrace.end(); ++it)
+            if (*it != this)
                 this->parents_.insert(*it);
     }

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

@@ -148 +148 @@
             Identifier& inheritsFrom(Identifier* directParent);
 
-            void initializeParents(Identifiable* instance, const std::set<const Identifier*>& identifiers);
+            void initializeParents(const std::set<const Identifier*>& initializationTrace);
             void initializeDirectParentsOfAbstractClass();
             void finishInitialization();

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

@@ -118 +118 @@
                 if (it->second->hasFactory())
                 {
-                    this->identifiersOfNewObject_.clear();
+                    this->identifierTraceOfNewObject_.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;
 
-                    it->second->initializeParents(temp, this->identifiersOfNewObject_);
+                    it->second->initializeParents(this->identifierTraceOfNewObject_[temp]);
 
                     delete temp;
@@ -209 +209 @@
     {
         if (this->isCreatingHierarchy())
-            this->identifiersOfNewObject_.insert(identifiable->getIdentifier());
+            this->identifierTraceOfNewObject_[identifiable].insert(identifiable->getIdentifier());
         else
             orxout(internal_warning) << "createdObject() called outside of class hierarchy creation" << endl;

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

@@ -107 +107 @@
 
             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)
-            std::set<const Identifier*> identifiersOfNewObject_;    //!< Used while creating the object hierarchy to keep track of the identifiers of a newly created object
             unsigned int classIDCounter_s;                          //!< counter for the unique classIDs
+
+            /// Used while creating the object hierarchy to keep track of the identifiers of a newly created object (and all other objects that get created as
+            /// a consequence of this, e.g. nested member objects).
+            std::map<Identifiable*, std::set<const Identifier*> > identifierTraceOfNewObject_;
     };
 }