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 7ef1ea1dcfd6d498969647a4cc7fe6f71f669db1..5475c7dab99aaa6baf610ec6a6a3529d21b0b5bc 100644 (file)
--- a/source/builder.cpp
+++ b/source/builder.cpp
@@ -17,6 +17,7 @@
 #include "datatool.h"
 #include "gnutools.h"
 #include "installedfile.h"
+#include "microsofttools.h"
 #include "package.h"
 #include "sharedlibrary.h"
 #include "sourcepackage.h"
@@ -64,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;
 }
 
@@ -89,6 +90,8 @@ void Builder::add_default_tools()
        const string &arch_tc = current_arch->get_toolchain();
        if(current_arch->get_system()=="android")
                toolchain.add_toolchain(new AndroidTools(*this, *current_arch));
+       else if(arch_tc=="msvc")
+               toolchain.add_toolchain(new MicrosoftTools(*this, *current_arch));
        else if(arch_tc=="clang")
                toolchain.add_toolchain(new ClangTools(*this, *current_arch));
        else if(arch_tc=="gnu")
@@ -109,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;
 }
@@ -166,6 +158,12 @@ void Builder::load_build_file(const FS::Path &fn, const Config::InputOptions *op
        loader.load(parser);
 }
 
+void Builder::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)
 {
        unsigned total = build_graph.count_rebuild_targets();
@@ -253,13 +251,6 @@ int Builder::build(unsigned jobs, bool dry_run, bool show_progress)
        else if(show_progress)
                get_logger().log("summary", "Build complete");
 
-       if(!dry_run)
-       {
-               const PackageManager::PackageMap &packages = package_manager.get_packages();
-               for(PackageManager::PackageMap::const_iterator i=packages.begin(); i!=packages.end(); ++i)
-                       i->second->save_caches();
-       }
-
        return fail;
 }
 
@@ -279,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;