Changeset 10916 for code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc

Timestamp:

Dec 2, 2015, 11:22:03 PM (9 years ago)

Author:

landauf

Message:

use actual types instead of 'auto'. only exception is for complicated template types, e.g. when iterating over a map

File:

• code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc (modified) (5 diffs)

code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc

@@ -293 +293 @@
         {
             // No it's not: Search for classes inheriting from the given class and add the rules for them
-            for (const auto & elem : subclass->getDirectChildren())
-                if ((elem)->isA(this->root_->getClass()))
-                    if (overwrite || (!this->nodeExists(elem))) // If we don't want to overwrite, only add nodes that don't already exist
-                        this->add(this->root_, elem, bInclude, overwrite);
+            for (const Identifier* directChild : subclass->getDirectChildren())
+                if (directChild->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(directChild))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, directChild, bInclude, overwrite);
         }
 
@@ -325 +325 @@
         {
             // Search for an already existing node, containing the subclass we want to add
-            for (auto & elem : node->subnodes_)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
-                if (subclass->isA((elem)->getClass()))
+                if (subclass->isA(subnode->getClass()))
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(elem, subclass, bInclude, overwrite);
+                    this->add(subnode, subclass, bInclude, overwrite);
                     return;
                 }
@@ -392 +392 @@
         if (!subclass)
             return;
-        for (const auto & elem : subclass->getDirectChildren())
-            this->add(elem, this->isIncluded(elem), false, false);
+        for (const Identifier* directChild : subclass->getDirectChildren())
+            this->add(directChild, this->isIncluded(directChild), false, false);
 
         this->add(subclass, bInclude, false, clean);
@@ -435 +435 @@
 
             // Go through the list of subnodes and look for a node containing the searched subclass and delegate the request by a recursive function-call.
-            for (auto & elem : node->subnodes_)
-                if (subclass->isA((elem)->getClass()))
-                    return isIncluded(elem, subclass);
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
+                if (subclass->isA(subnode->getClass()))
+                    return isIncluded(subnode, subclass);
 
             // There is no subnode containing our class -> the rule of the current node takes in effect
@@ -957 +957 @@
             // The bool is "false", meaning they have no subnodes and therefore need no further checks
             if (node->isIncluded())
-                for (const auto & elem : directChildren)
-                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(elem, false));
+                for (const Identifier* directChild : directChildren)
+                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(directChild, false));
         }
     }