Changeset 10821 for code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc

Timestamp:

Nov 21, 2015, 7:05:53 PM (8 years ago)

Author:

muemart

Message:

Run clang-modernize -loop-convert

• Again, not all possible loops were converted
• It can do pretty cool transformations, but I had to fix a few compile errors, so there might be some runtime errors lurking around too

File:

• code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc (modified) (3 diffs)

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

@@ -99 +99 @@
         std::set<Identifier*> identifiers;
         const std::set<StaticallyInitializedInstance*>& instances = module->getInstances(StaticInitialization::IDENTIFIER);
-        for (std::set<StaticallyInitializedInstance*>::const_iterator it = instances.begin(); it != instances.end(); ++it)
-            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(*it)->getIdentifier());
+        for (const auto & instance : instances)
+            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
 
         // destroy objects. some objects may survive this at first because they still have strong pointers pointing at them. this is
@@ -106 +106 @@
         // that objects within one module may reference each other by strong pointers. but it is not allowed that objects from another
         // module (which is not unloaded) uses strong pointers to point at objects inside the unloaded module. this will lead to a crash.
-        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
-            (*it)->destroyObjects();
+        for (const auto & identifier : identifiers)
+            (identifier)->destroyObjects();
 
         // check if all objects were really destroyed. this is not the case if an object is referenced by a strong pointer from another
         // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
         // changing object dependencies; or by changing the logic that allows modules to be unloaded).
-        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+        for (const auto & identifier : identifiers)
         {
-            ObjectListBase* objectList = Context::getRootContext()->getObjectList(*it);
+            ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
             if (objectList->size() > 0)
             {
-                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (*it)->getName()
+                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (identifier)->getName()
                     << " after unloading the Identifier. This may lead to a crash" << endl;
             }
@@ -123 +123 @@
 
         // destroy object-lists in all contexts
-        for (std::set<Identifier*>::iterator it_identifier = identifiers.begin(); it_identifier != identifiers.end(); ++it_identifier)
+        for (const auto & identifier : identifiers)
         {
             // only do this if the Identifier is not a Context itself; otherwise we delete the list we're iterating over
-            if (!(*it_identifier)->isExactlyA(Class(Context)))
+            if (!(identifier)->isExactlyA(Class(Context)))
             {
                 // iterate over all contexts
                 for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
-                    it_context->destroyObjectList((*it_identifier));
+                    it_context->destroyObjectList((identifier));
             }
         }