Modernize loops to use C++11 range-based-for

Author: leekillough

src/sst/core/baseComponent.cc

@@ -993,8 +993,8 @@ BaseComponent::addWatchPointRecursive(WatchPoint* pt)
 
 
     // Call for my subcomponents
-    for ( auto it = my_info_->subComponents.begin(); it != my_info_->subComponents.end(); ++it ) {
-        it->second.component->addWatchPointRecursive(pt);
+    for ( auto& subComponent : my_info_->subComponents ) {
+        subComponent.second.component->addWatchPointRecursive(pt);
     }
 }
 
@@ -1036,8 +1036,8 @@ BaseComponent::removeWatchPointRecursive(WatchPoint* pt)
     }
 
     // Call for my subcomponents
-    for ( auto it = my_info_->subComponents.begin(); it != my_info_->subComponents.end(); ++it ) {
-        it->second.component->removeWatchPointRecursive(pt);
+    for ( auto& subComponent : my_info_->subComponents ) {
+        subComponent.second.component->removeWatchPointRecursive(pt);
     }
 }
 

src/sst/core/componentInfo.cc

@@ -197,8 +197,8 @@ ComponentInfo::serialize_comp(SST::Core::Serialization::serializer& ser)
 {
     SST_SER(component);
     SST_SER(link_map);
-    for ( auto it = subComponents.begin(); it != subComponents.end(); ++it ) {
-        it->second.serialize_comp(ser);
+    for ( auto& subComponent : subComponents ) {
+        subComponent.second.serialize_comp(ser);
     }
 }
 

src/sst/core/configBase.cc

@@ -160,16 +160,15 @@ ConfigBase::parseWallTimeToSeconds(const std::string& arg, bool& success, const
     }
 
     static const char* templates[] = { "%H:%M:%S", "%M:%S", "%S", "%Hh", "%Mm", "%Ss" };
-    const size_t       n_templ     = sizeof(templates) / sizeof(templates[0]);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
     struct tm res = {}; /* This warns on GCC 4.8 due to a bug in GCC */
 #pragma GCC diagnostic pop
     char* p;
 
-    for ( size_t i = 0; i < n_templ; i++ ) {
+    for ( auto& i : templates ) {
         memset(&res, '\0', sizeof(res));
-        p = strptime(arg.c_str(), templates[i], &res);
+        p = strptime(arg.c_str(), i, &res);
         if ( p != nullptr && *p == '\0' ) {
             seconds = res.tm_sec;
             seconds += res.tm_min * 60;
@@ -181,8 +180,8 @@ ConfigBase::parseWallTimeToSeconds(const std::string& arg, bool& success, const
     fprintf(stderr,
         "ERROR: for option \"%s\", wall time argument could not be parsed. Argument = [%s]\nValid formats are:\n",
         option.c_str(), arg.c_str());
-    for ( size_t i = 0; i < n_templ; i++ ) {
-        fprintf(stderr, "\t%s\n", templates[i]);
+    for ( auto& i : templates ) {
+        fprintf(stderr, "\t%s\n", i);
     }
     success = false;
     // Let caller handle error
@@ -301,8 +300,8 @@ ConfigBase::printUsage()
     if ( has_extended_help_ ) {
         fprintf(stderr, "\nOptions annotated with 'H' have extended help available\n");
     }
-    for ( size_t i = 0; i < annotations_.size(); ++i ) {
-        fprintf(stderr, "%s\n", annotations_[i].help.c_str());
+    for ( auto& annotation : annotations_ ) {
+        fprintf(stderr, "%s\n", annotation.help.c_str());
     }
 
     // Print info about annotations

src/sst/core/configShared.cc

@@ -102,14 +102,13 @@ ConfigShared::getLibPath(bool exclude_ext_paths) const
         std::set<std::string> configGroups = envConfig->getGroupNames();
 
         // iterate over groups of settings
-        for ( auto groupItr = configGroups.begin(); groupItr != configGroups.end(); groupItr++ ) {
-            SST::Core::Environment::EnvironmentConfigGroup* currentGroup = envConfig->getGroupByName(*groupItr);
+        for ( const auto& configGroup : configGroups ) {
+            SST::Core::Environment::EnvironmentConfigGroup* currentGroup = envConfig->getGroupByName(configGroup);
             std::set<std::string>                           groupKeys    = currentGroup->getKeys();
 
             // find which keys have a LIBDIR at the END of the key we
             // recognize these may house elements
-            for ( auto keyItr = groupKeys.begin(); keyItr != groupKeys.end(); keyItr++ ) {
-                const std::string& key   = *keyItr;
+            for ( const auto& key : groupKeys ) {
                 const std::string& value = currentGroup->getValue(key);
 
                 if ( key.size() >= 6 ) {

src/sst/core/env/envconfig.cc

@@ -38,8 +38,8 @@ SST::Core::Environment::EnvironmentConfigGroup::getKeys() const
 {
     std::set<std::string> retKeys;
 
-    for ( auto mapItr = params.begin(); mapItr != params.end(); mapItr++ ) {
-        retKeys.insert(mapItr->first);
+    for ( const auto& param : params ) {
+        retKeys.insert(param.first);
     }
 
     return retKeys;
@@ -80,8 +80,8 @@ SST::Core::Environment::EnvironmentConfigGroup::print()
 
     printf("\n");
 
-    for ( auto paramsItr = params.begin(); paramsItr != params.end(); paramsItr++ ) {
-        printf("%s=%s\n", paramsItr->first.c_str(), paramsItr->second.c_str());
+    for ( auto& param : params ) {
+        printf("%s=%s\n", param.first.c_str(), param.second.c_str());
     }
 }
 
@@ -90,8 +90,8 @@ SST::Core::Environment::EnvironmentConfigGroup::writeTo(FILE* outFile)
 {
     fprintf(outFile, "\n[%s]\n", groupName.c_str());
 
-    for ( auto paramsItr = params.begin(); paramsItr != params.end(); paramsItr++ ) {
-        fprintf(outFile, "%s=%s\n", paramsItr->first.c_str(), paramsItr->second.c_str());
+    for ( auto& param : params ) {
+        fprintf(outFile, "%s=%s\n", param.first.c_str(), param.second.c_str());
     }
 }
 
@@ -100,8 +100,8 @@ SST::Core::Environment::EnvironmentConfiguration::EnvironmentConfiguration() {}
 SST::Core::Environment::EnvironmentConfiguration::~EnvironmentConfiguration()
 {
     // Delete all the groups we have created
-    for ( auto groupItr = groups.begin(); groupItr != groups.end(); groupItr++ ) {
-        delete groupItr->second;
+    for ( auto& group : groups ) {
+        delete group.second;
     }
 }
 
@@ -136,8 +136,8 @@ SST::Core::Environment::EnvironmentConfiguration::getGroupNames()
 {
     std::set<std::string> groupNames;
 
-    for ( auto groupItr = groups.begin(); groupItr != groups.end(); groupItr++ ) {
-        groupNames.insert(groupItr->first);
+    for ( auto& group : groups ) {
+        groupNames.insert(group.first);
     }
 
     return groupNames;
@@ -152,8 +152,8 @@ SST::Core::Environment::EnvironmentConfiguration::getGroupByName(const std::stri
 void
 SST::Core::Environment::EnvironmentConfiguration::print()
 {
-    for ( auto groupItr = groups.begin(); groupItr != groups.end(); groupItr++ ) {
-        groupItr->second->print();
+    for ( auto& group : groups ) {
+        group.second->print();
     }
 }
 
@@ -173,8 +173,8 @@ SST::Core::Environment::EnvironmentConfiguration::writeTo(const std::string& fil
     // exclusive since no one else should muck with it)
     flock(outputFD, LOCK_EX);
 
-    for ( auto groupItr = groups.begin(); groupItr != groups.end(); groupItr++ ) {
-        groupItr->second->writeTo(output);
+    for ( auto& group : groups ) {
+        group.second->writeTo(output);
     }
 
     flock(outputFD, LOCK_UN);
@@ -184,7 +184,7 @@ SST::Core::Environment::EnvironmentConfiguration::writeTo(const std::string& fil
 void
 SST::Core::Environment::EnvironmentConfiguration::writeTo(FILE* output)
 {
-    for ( auto groupItr = groups.begin(); groupItr != groups.end(); groupItr++ ) {
-        groupItr->second->writeTo(output);
+    for ( auto& group : groups ) {
+        group.second->writeTo(output);
     }
 }

src/sst/core/env/envquery.cc

@@ -198,7 +198,7 @@ SST::Core::Environment::getSSTEnvironmentConfiguration(const std::vector<std::st
     }
 
     // NEXT - override paths
-    for ( std::string nextPath : overridePaths ) {
+    for ( const std::string& nextPath : overridePaths ) {
         populateEnvironmentConfig(nextPath, envConfig, true);
     }
 

src/sst/core/factory.cc

@@ -632,8 +632,8 @@ Factory::getLoadedLibraryNames(std::set<std::string>& lib_names)
 void
 Factory::loadUnloadedLibraries(const std::set<std::string>& lib_names)
 {
-    for ( std::set<std::string>::const_iterator i = lib_names.begin(); i != lib_names.end(); ++i ) {
-        findLibrary(*i);
+    for ( const auto& lib_name : lib_names ) {
+        findLibrary(lib_name);
     }
 }
 

src/sst/core/impl/partitioners/rrobin.cc

@@ -29,9 +29,9 @@ SSTRoundRobinPartition::performPartition(PartitionGraph* graph)
     PartitionComponentMap_t& compMap = graph->getComponentMap();
     RankInfo                 rank(0, 0);
 
-    for ( PartitionComponentMap_t::iterator compItr = compMap.begin(); compItr != compMap.end(); compItr++ ) {
+    for ( auto& compItr : compMap ) {
 
-        (*compItr)->rank = rank;
+        compItr->rank = rank;
 
         rank.rank++;
         if ( rank.rank == world_size.rank ) {

src/sst/core/impl/partitioners/simplepart.cc

@@ -74,9 +74,9 @@ cost_external_links(ComponentId_t* setA, const int lengthA, ComponentId_t* setB,
 
     for ( int i = 0; i < lengthA; i++ ) {
         auto* compMap = timeTable[setA[i]];
-        for ( auto compMapItr = compMap->cbegin(); compMapItr != compMap->cend(); compMapItr++ ) {
-            if ( findIndex(setB, lengthB, compMapItr->first) > -1 ) {
-                cost += compMapItr->second;
+        for ( auto compMapItr : *compMap ) {
+            if ( findIndex(setB, lengthB, compMapItr.first) > -1 ) {
+                cost += compMapItr.second;
             }
         }
     }
@@ -186,10 +186,9 @@ SimplePartitioner::performPartition(PartitionGraph* graph)
     PartitionComponentMap_t& component_map = graph->getComponentMap();
 
     if ( total_parts == 1 ) {
-        for ( PartitionComponentMap_t::iterator compItr = component_map.begin(); compItr != component_map.end();
-            ++compItr ) {
+        for ( auto& compItr : component_map ) {
 
-            (*compItr)->rank = RankInfo(0, 0);
+            compItr->rank = RankInfo(0, 0);
         }
     }
     else {
@@ -211,10 +210,9 @@ SimplePartitioner::performPartition(PartitionGraph* graph)
 
         // size_t nComp = component_map.size();
         // for(size_t theComponent = 0 ; theComponent < nComp ; theComponent++ ) {
-        for ( PartitionComponentMap_t::iterator compItr = component_map.begin(); compItr != component_map.end();
-            ++compItr ) {
+        for ( auto& compItr : component_map ) {
 
-            ComponentId_t theComponent = (*compItr)->id;
+            ComponentId_t theComponent = compItr->id;
 
             auto compConnectMap = timeTable[theComponent] = new std::map<ComponentId_t, SimTime_t>();
 
@@ -225,15 +223,14 @@ SimplePartitioner::performPartition(PartitionGraph* graph)
                 setB[indexB++] = theComponent;
             }
 
-            LinkIdMap_t component_links = (*compItr)->links;
+            LinkIdMap_t component_links = compItr->links;
 
             PartitionLinkMap_t& linkMap = graph->getLinkMap();
 
-            for ( LinkIdMap_t::const_iterator linkItr = component_links.begin(); linkItr != component_links.end();
-                linkItr++ ) {
+            for ( unsigned int component_link : component_links ) {
 
                 // ConfigLink* theLink = (*linkItr);
-                PartitionLink& theLink = linkMap[*linkItr];
+                PartitionLink& theLink = linkMap[component_link];
                 compConnectMap->insert(
                     std::pair<ComponentId_t, SimTime_t>(theLink.component[1], theLink.getMinLatency()));
             }

src/sst/core/impl/timevortex/timeVortexPQ.cc

@@ -102,8 +102,8 @@ TimeVortexPQBase<TS>::dbg_print(Output& out) const
 
     //  STL's priority_queue does not support iteration.
     const std::vector<Activity*>& act = getContainer();
-    for ( auto it = act.begin(); it != act.end(); it++ ) {
-        (*it)->print("  ", out);
+    for ( auto it : act ) {
+        it->print("  ", out);
     }
 }