Use C++11 range-based loops in extensions

Also use `auto` and structured binding for iterators.

This is based on running `clang-tidy` with the `modernize-loop-convert`
and `modernize-use-auto` checks. Note though that I did not (yet) apply
any `auto` suggestions that were not `for` loops.

Author: QuLogic

src/_backend_agg_basic_types.h

@@ -59,9 +59,7 @@ class Dashes
     void dash_to_stroke(T &stroke, double dpi, bool isaa)
     {
         double scaleddpi = dpi / 72.0;
-        for (dash_t::const_iterator i = dashes.begin(); i != dashes.end(); ++i) {
-            double val0 = i->first;
-            double val1 = i->second;
+        for (auto [val0, val1] : dashes) {
             val0 = val0 * scaleddpi;
             val1 = val1 * scaleddpi;
             if (!isaa) {

src/_path.h

@@ -602,24 +602,20 @@ struct ygt : public bisecty
 template <class Filter>
 inline void clip_to_rect_one_step(const Polygon &polygon, Polygon &result, const Filter &filter)
 {
-    double sx, sy, px, py, bx, by;
     bool sinside, pinside;
     result.clear();
 
     if (polygon.size() == 0) {
         return;
     }
 
-    sx = polygon.back().x;
-    sy = polygon.back().y;
-    for (Polygon::const_iterator i = polygon.begin(); i != polygon.end(); ++i) {
-        px = i->x;
-        py = i->y;
-
+    auto [sx, sy] = polygon.back();
+    for (auto [px, py] : polygon) {
         sinside = filter.is_inside(sx, sy);
         pinside = filter.is_inside(px, py);
 
         if (sinside ^ pinside) {
+            double bx, by;
             filter.bisect(sx, sy, px, py, &bx, &by);
             result.push_back(XY(bx, by));
         }

src/ft2font.cpp

@@ -293,8 +293,8 @@ FT2Font::FT2Font(FT_Open_Args &open_args,
 
 FT2Font::~FT2Font()
 {
-    for (size_t i = 0; i < glyphs.size(); i++) {
-        FT_Done_Glyph(glyphs[i]);
+    for (auto & glyph : glyphs) {
+        FT_Done_Glyph(glyph);
     }
 
     if (face) {
@@ -308,16 +308,16 @@ void FT2Font::clear()
     bbox.xMin = bbox.yMin = bbox.xMax = bbox.yMax = 0;
     advance = 0;
 
-    for (size_t i = 0; i < glyphs.size(); i++) {
-        FT_Done_Glyph(glyphs[i]);
+    for (auto & glyph : glyphs) {
+        FT_Done_Glyph(glyph);
     }
 
     glyphs.clear();
     glyph_to_font.clear();
     char_to_font.clear();
 
-    for (size_t i = 0; i < fallbacks.size(); i++) {
-        fallbacks[i]->clear();
+    for (auto & fallback : fallbacks) {
+        fallback->clear();
     }
 }
 
@@ -331,8 +331,8 @@ void FT2Font::set_size(double ptsize, double dpi)
     FT_Matrix transform = { 65536 / hinting_factor, 0, 0, 65536 };
     FT_Set_Transform(face, &transform, 0);
 
-    for (size_t i = 0; i < fallbacks.size(); i++) {
-        fallbacks[i]->set_size(ptsize, dpi);
+    for (auto & fallback : fallbacks) {
+        fallback->set_size(ptsize, dpi);
     }
 }
 
@@ -393,8 +393,8 @@ int FT2Font::get_kerning(FT_UInt left, FT_UInt right, FT_Kerning_Mode mode,
 void FT2Font::set_kerning_factor(int factor)
 {
     kerning_factor = factor;
-    for (size_t i = 0; i < fallbacks.size(); i++) {
-        fallbacks[i]->set_kerning_factor(factor);
+    for (auto & fallback : fallbacks) {
+        fallback->set_kerning_factor(factor);
     }
 }
 
@@ -594,8 +594,8 @@ bool FT2Font::load_char_with_fallback(FT2Font *&ft_object_with_glyph,
         return true;
     }
     else {
-        for (size_t i = 0; i < fallbacks.size(); ++i) {
-            bool was_found = fallbacks[i]->load_char_with_fallback(
+        for (auto & fallback : fallbacks) {
+            bool was_found = fallback->load_char_with_fallback(
                 ft_object_with_glyph, final_glyph_index, parent_glyphs,
                 parent_char_to_font, parent_glyph_to_font, charcode, flags,
                 charcode_error, glyph_error, glyph_seen_fonts, override);
@@ -674,14 +674,14 @@ void FT2Font::draw_glyphs_to_bitmap(bool antialiased)
 
     image.resize(width, height);
 
-    for (size_t n = 0; n < glyphs.size(); n++) {
+    for (auto & glyph : glyphs) {
         FT_Error error = FT_Glyph_To_Bitmap(
-            &glyphs[n], antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);
+            &glyph, antialiased ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO, 0, 1);
         if (error) {
             throw_ft_error("Could not convert glyph to bitmap", error);
         }
 
-        FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];
+        FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph;
         // now, draw to our target surface (convert position)
 
         // bitmap left and top in pixel, string bbox in subpixel

src/tri/_tri.cpp

@@ -184,8 +184,9 @@ void ContourLine::push_back(const XY& point)
 void ContourLine::write() const
 {
     std::cout << "ContourLine of " << size() << " points:";
-    for (const_iterator it = begin(); it != end(); ++it)
-        std::cout << ' ' << *it;
+    for (const auto & it : *this) {
+        std::cout << ' ' << it;
+    }
     std::cout << std::endl;
 }
 
@@ -194,8 +195,9 @@ void ContourLine::write() const
 void write_contour(const Contour& contour)
 {
     std::cout << "Contour of " << contour.size() << " lines." << std::endl;
-    for (Contour::const_iterator it = contour.begin(); it != contour.end(); ++it)
-        it->write();
+    for (const auto & it : contour) {
+        it.write();
+    }
 }
 
 
@@ -264,7 +266,7 @@ void Triangulation::calculate_boundaries()
     // time, initialise the _tri_edge_to_boundary_map.
     while (!boundary_edges.empty()) {
         // Start of new boundary.
-        BoundaryEdges::iterator it = boundary_edges.begin();
+        auto it = boundary_edges.cbegin();
         int tri = it->tri;
         int edge = it->edge;
         _boundaries.push_back(Boundary());
@@ -321,9 +323,9 @@ void Triangulation::calculate_edges()
     auto edges = _edges.mutable_data();
 
     int i = 0;
-    for (EdgeSet::const_iterator it = edge_set.begin(); it != edge_set.end(); ++it) {
-        edges[i++] = it->start;
-        edges[i++] = it->end;
+    for (const auto & it : edge_set) {
+        edges[i++] = it.start;
+        edges[i++] = it.end;
     }
 }
 
@@ -351,8 +353,7 @@ void Triangulation::calculate_neighbors()
             for (edge = 0; edge < 3; ++edge) {
                 int start = get_triangle_point(tri, edge);
                 int end   = get_triangle_point(tri, (edge+1)%3);
-                EdgeToTriEdgeMap::iterator it =
-                    edge_to_tri_edge_map.find(Edge(end,start));
+                const auto it = edge_to_tri_edge_map.find(Edge(end, start));
                 if (it == edge_to_tri_edge_map.end()) {
                     // No neighbor edge exists in the edge_to_tri_edge_map, so
                     // add this edge to it.
@@ -464,10 +465,8 @@ void Triangulation::get_boundary_edge(const TriEdge& triEdge,
                                       int& edge) const
 {
     get_boundaries();  // Ensure _tri_edge_to_boundary_map has been created.
-    TriEdgeToBoundaryMap::const_iterator it =
-        _tri_edge_to_boundary_map.find(triEdge);
-    assert(it != _tri_edge_to_boundary_map.end() &&
-           "TriEdge is not on a boundary");
+    const auto it = _tri_edge_to_boundary_map.find(triEdge);
+    assert(it != _tri_edge_to_boundary_map.end() && "TriEdge is not on a boundary");
     boundary = it->second.boundary;
     edge = it->second.edge;
 }
@@ -587,13 +586,12 @@ void Triangulation::set_mask(const MaskArray& mask)
 
 void Triangulation::write_boundaries() const
 {
-    const Boundaries& bs = get_boundaries();
-    std::cout << "Number of boundaries: " << bs.size() << std::endl;
-    for (Boundaries::const_iterator it = bs.begin(); it != bs.end(); ++it) {
-        const Boundary& b = *it;
-        std::cout << "  Boundary of " << b.size() << " points: ";
-        for (Boundary::const_iterator itb = b.begin(); itb != b.end(); ++itb) {
-            std::cout << *itb << ", ";
+    const Boundaries& boundaries = get_boundaries();
+    std::cout << "Number of boundaries: " << boundaries.size() << std::endl;
+    for (const auto & boundary : boundaries) {
+        std::cout << "  Boundary of " << boundary.size() << " points: ";
+        for (const auto & point : boundary) {
+            std::cout << point << ", ";
         }
         std::cout << std::endl;
     }
@@ -625,18 +623,18 @@ void TriContourGenerator::clear_visited_flags(bool include_boundaries)
 
             // Initialise _boundaries_visited.
             _boundaries_visited.reserve(boundaries.size());
-            for (Boundaries::const_iterator it = boundaries.begin();
-                    it != boundaries.end(); ++it)
-                _boundaries_visited.push_back(BoundaryVisited(it->size()));
+            for (const auto & boundary : boundaries) {
+                _boundaries_visited.push_back(BoundaryVisited(boundary.size()));
+            }
 
             // Initialise _boundaries_used.
             _boundaries_used = BoundariesUsed(boundaries.size());
         }
 
         // Clear _boundaries_visited.
-        for (BoundariesVisited::iterator it = _boundaries_visited.begin();
-                it != _boundaries_visited.end(); ++it)
-            std::fill(it->begin(), it->end(), false);
+        for (auto & it : _boundaries_visited) {
+            std::fill(it.begin(), it.end(), false);
+        }
 
         // Clear _boundaries_used.
         std::fill(_boundaries_used.begin(), _boundaries_used.end(), false);
@@ -672,12 +670,12 @@ py::tuple TriContourGenerator::contour_line_to_segs_and_kinds(const Contour& con
         CodeArray codes(codes_dims);
         unsigned char* codes_ptr = codes.mutable_data();
 
-        for (ContourLine::const_iterator it = contour_line.begin();
-             it != contour_line.end(); ++it) {
-            *segs_ptr++ = it->x;
-            *segs_ptr++ = it->y;
-            *codes_ptr++ = (it == contour_line.begin() ? MOVETO : LINETO);
+        for (const auto & point : contour_line) {
+            *segs_ptr++ = point.x;
+            *segs_ptr++ = point.y;
+            *codes_ptr++ = LINETO;
         }
+        *codes.mutable_data(0) = MOVETO;
 
         // Closed line loop has identical first and last (x, y) points.
         if (contour_line.size() > 1 &&
@@ -707,13 +705,11 @@ py::tuple TriContourGenerator::contour_to_segs_and_kinds(const Contour& contour)
     // and they are returned in the Python lists vertices_list and codes_list
     // respectively.
 
-    Contour::const_iterator line;
-    ContourLine::const_iterator point;
-
     // Find total number of points in all contour lines.
     py::ssize_t n_points = 0;
-    for (line = contour.begin(); line != contour.end(); ++line)
-        n_points += static_cast<py::ssize_t>(line->size());
+    for (const auto & line : contour) {
+        n_points += static_cast<py::ssize_t>(line.size());
+    }
 
     // Create segs array for point coordinates.
     py::ssize_t segs_dims[2] = {n_points, 2};
@@ -725,15 +721,16 @@ py::tuple TriContourGenerator::contour_to_segs_and_kinds(const Contour& contour)
     CodeArray codes(codes_dims);
     unsigned char* codes_ptr = codes.mutable_data();
 
-    for (line = contour.begin(); line != contour.end(); ++line) {
-        for (point = line->begin(); point != line->end(); point++) {
+    for (const auto & line : contour) {
+        for (auto point = line.cbegin(); point != line.cend(); point++) {
             *segs_ptr++ = point->x;
             *segs_ptr++ = point->y;
-            *codes_ptr++ = (point == line->begin() ? MOVETO : LINETO);
+            *codes_ptr++ = (point == line.cbegin() ? MOVETO : LINETO);
         }
 
-        if (line->size() > 1)
+        if (line.size() > 1) {
             *(codes_ptr-1) = CLOSEPOLY;
+        }
     }
 
     py::list vertices_list(1);
@@ -787,13 +784,10 @@ void TriContourGenerator::find_boundary_lines(Contour& contour,
     // line to its end before continuing.
     const Triangulation& triang = _triangulation;
     const Boundaries& boundaries = get_boundaries();
-    for (Boundaries::const_iterator it = boundaries.begin();
-            it != boundaries.end(); ++it) {
-        const Boundary& boundary = *it;
+    for (const auto & boundary : boundaries) {
         bool startAbove, endAbove = false;
-        for (Boundary::const_iterator itb = boundary.begin();
-                itb != boundary.end(); ++itb) {
-            if (itb == boundary.begin())
+        for (auto itb = boundary.cbegin(); itb != boundary.cend(); ++itb) {
+            if (itb == boundary.cbegin())
                 startAbove = get_z(triang.get_triangle_point(*itb)) >= level;
             else
                 startAbove = endAbove;
@@ -867,9 +861,10 @@ void TriContourGenerator::find_boundary_lines_filled(Contour& contour,
             if (z >= lower_level && z < upper_level) {
                 contour.push_back(ContourLine());
                 ContourLine& contour_line = contour.back();
-                for (Boundary::size_type j = 0; j < boundary.size(); ++j)
+                for (auto edge : boundary) {
                     contour_line.push_back(triang.get_point_coords(
-                                      triang.get_triangle_point(boundary[j])));
+                                      triang.get_triangle_point(edge)));
+                }
 
                 // Close polygon.
                 contour_line.push_back(contour_line.front());
@@ -1638,9 +1633,7 @@ TrapezoidMapTriFinder::Node::assert_valid(bool tree_complete) const
 {
 #ifndef NDEBUG
     // Check parents.
-    for (Parents::const_iterator it = _parents.begin();
-         it != _parents.end(); ++it) {
-        Node* parent = *it;
+    for (const auto & parent : _parents) {
         assert(parent != this && "Cannot be parent of self");
         assert(parent->has_child(this) && "Parent missing child");
     }
@@ -1779,7 +1772,7 @@ TrapezoidMapTriFinder::Node::remove_parent(Node* parent)
 {
     assert(parent != 0 && "Null parent");
     assert(parent != this && "Cannot be parent of self");
-    Parents::iterator it = std::find(_parents.begin(), _parents.end(), parent);
+    auto it = std::find(_parents.begin(), _parents.end(), parent);
     assert(it != _parents.end() && "Parent not in collection");
     _parents.erase(it);
     return _parents.empty();