Replace basic for loops with range-based loops or algorithms

[builder.git] / source / builder.cpp

diff --git a/source/builder.cpp b/source/builder.cpp
index e26c1157ec88ff5b06a3f08710d41a16cfcbf442..5475c7dab99aaa6baf610ec6a6a3529d21b0b5bc 100644 (file)
--- a/source/builder.cpp
+++ b/source/builder.cpp
@@ -65,8 +65,8 @@ vector<string> Builder::get_build_types() const
 {
        vector<string> keys;
        keys.reserve(build_types.size());
-       for(BuildTypeMap::const_iterator i=build_types.begin(); i!=build_types.end(); ++i)
-               keys.push_back(i->first);
+       for(const auto &kvp: build_types)
+               keys.push_back(kvp.first);
        return keys;
 }
 
@@ -112,48 +112,37 @@ list<string> Builder::collect_problems() const
        set<const Component *> broken_components;
        set<const Tool *> broken_tools;
 
-       const BuildGraph::TargetMap &targets = build_graph.get_targets();
-       for(BuildGraph::TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
-               if(i->second->is_broken())
+       for(const auto &kvp: build_graph.get_targets())
+               if(kvp.second->is_broken())
                {
-                       const list<string> &tgt_problems = i->second->get_problems();
-                       for(list<string>::const_iterator j=tgt_problems.begin(); j!=tgt_problems.end(); ++j)
-                               problems.push_back(format("%s: %s", i->second->get_name(), *j));
+                       for(const string &p: kvp.second->get_problems())
+                               problems.push_back(format("%s: %s", kvp.second->get_name(), p));
 
-                       const Package *package = i->second->get_package();
+                       const Package *package = kvp.second->get_package();
                        if(package && !package->get_problems().empty())
                                broken_packages.insert(package);
 
-                       const Component *component = i->second->get_component();
+                       const Component *component = kvp.second->get_component();
                        if(component && !component->get_problems().empty())
                                broken_components.insert(component);
 
-                       const Tool *tool = i->second->get_tool();
+                       const Tool *tool = kvp.second->get_tool();
                        if(tool && !tool->get_problems().empty())
                                broken_tools.insert(tool);
                }
 
        // TODO Sort components after their packages, and targets last
-       for(set<const Package *>::const_iterator i=broken_packages.begin(); i!=broken_packages.end(); ++i)
-       {
-               const list<string> &pkg_problems = (*i)->get_problems();
-               for(list<string>::const_iterator j=pkg_problems.begin(); j!=pkg_problems.end(); ++j)
-                       problems.push_back(format("%s: %s", (*i)->get_name(), *j));
-       }
+       for(const Package *p: broken_packages)
+               for(const string &b: p->get_problems())
+                       problems.push_back(format("%s: %s", p->get_name(), b));
 
-       for(set<const Component *>::const_iterator i=broken_components.begin(); i!=broken_components.end(); ++i)
-       {
-               const list<string> &comp_problems = (*i)->get_problems();
-               for(list<string>::const_iterator j=comp_problems.begin(); j!=comp_problems.end(); ++j)
-                       problems.push_back(format("%s/%s: %s", (*i)->get_package().get_name(), (*i)->get_name(), *j));
-       }
+       for(const Component *c: broken_components)
+               for(const string &b: c->get_problems())
+                       problems.push_back(format("%s/%s: %s", c->get_package().get_name(), c->get_name(), b));
 
-       for(set<const Tool *>::const_iterator i=broken_tools.begin(); i!=broken_tools.end(); ++i)
-       {
-               const list<string> &tool_problems = (*i)->get_problems();
-               for(list<string>::const_iterator j=tool_problems.begin(); j!=tool_problems.end(); ++j)
-                       problems.push_back(format("%s: %s", (*i)->get_tag(), *j));
-       }
+       for(const Tool *t: broken_tools)
+               for(const string &b: t->get_problems())
+                       problems.push_back(format("%s: %s", t->get_tag(), b));
 
        return problems;
 }
@@ -171,9 +160,8 @@ void Builder::load_build_file(const FS::Path &fn, const Config::InputOptions *op
 
 void Builder::save_caches()
 {
-       const PackageManager::PackageMap &packages = package_manager.get_packages();
-       for(PackageManager::PackageMap::const_iterator i=packages.begin(); i!=packages.end(); ++i)
-               i->second->save_caches();
+       for(const auto &kvp: package_manager.get_packages())
+               kvp.second->save_caches();
 }
 
 int Builder::build(unsigned jobs, bool dry_run, bool show_progress)
@@ -282,17 +270,16 @@ int Builder::clean(bool all, bool dry_run)
                if(tgt->is_buildable() && (tgt->get_package()==&package_manager.get_main_package() || all))
                        clean_tgts.insert(tgt);
 
-               const Target::Dependencies &deps = tgt->get_dependencies();
-               for(list<Target *>::const_iterator i=deps.begin(); i!=deps.end(); ++i)
-                       if(!clean_tgts.count(*i))
-                               queue.push_back(*i);
+               for(Target *t: tgt->get_dependencies())
+                       if(!clean_tgts.count(t))
+                               queue.push_back(t);
        }
 
-       for(set<Target *>::iterator i=clean_tgts.begin(); i!=clean_tgts.end(); ++i)
+       for(Target *t: clean_tgts)
        {
-               get_logger().log("tasks", format("RM    %s", (*i)->get_name()));
+               get_logger().log("tasks", format("RM    %s", t->get_name()));
                if(!dry_run)
-                       (*i)->clean();
+                       t->clean();
        }
 
        return 0;