Use iter pipelines more

src/hb-ot-layout-gsub-table.hh

@@ -46,9 +46,9 @@ struct SingleSubstFormat1
 
   void closure (hb_closure_context_t *c) const
   {
-    for (auto it = (this+coverage).iter (); it; ++it)
+    for (auto it = (this+coverage).iter ()
-      if (c->glyphs->has (*it))
+		 | hb_filter (*c->glyphs); it; ++it)
-        c->output->add ((*it + deltaGlyphID) & 0xFFFFu);
+      c->output->add ((*it + deltaGlyphID) & 0xFFFFu);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
@@ -100,12 +100,12 @@ struct SingleSubstFormat1
     hb_sorted_vector_t<GlyphID> from;
     hb_vector_t<GlyphID> to;
     hb_codepoint_t delta = deltaGlyphID;
-    for (auto it = (this+coverage).iter (); it; ++it)
+    for (auto it = (this+coverage).iter ()
-      if (glyphset.has (*it))
+		 | hb_filter (glyphset); it; ++it)
-      {
+    {
-	from.push ()->set (glyph_map[*it]);
+      from.push ()->set (glyph_map[*it]);
-	to.push ()->set (glyph_map[(*it + delta) & 0xFFFF]);
+      to.push ()->set (glyph_map[(*it + delta) & 0xFFFF]);
-      }
+    }
     c->serializer->propagate_error (from, to);
     SingleSubst_serialize (c->serializer, from, to);
     return_trace (from.length);
@@ -137,16 +137,16 @@ struct SingleSubstFormat2
   {
     for (auto it = hb_zip (this+coverage, substitute)
 		 | hb_filter (*c->glyphs, hb_first)
-		 | hb_map (hb_second);
+		 | hb_map (hb_second); it; ++it)
-	 it; ++it)
       c->output->add (*it);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   {
     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
-    for (auto it = hb_zip (this+coverage, substitute); it; ++it)
+    for (auto it = hb_zip (this+coverage, substitute)
-      c->output->add (it->second);
+		 | hb_map (hb_second); it; ++it)
+      c->output->add (*it);
   }
 
   const Coverage &get_coverage () const { return this+coverage; }
@@ -188,8 +188,8 @@ struct SingleSubstFormat2
     const hb_map_t &glyph_map = *c->plan->glyph_map;
     hb_sorted_vector_t<GlyphID> from;
     hb_vector_t<GlyphID> to;
-    for (auto it = hb_zip (this+coverage, substitute); it; ++it)
+    for (auto it = hb_zip (this+coverage, substitute)
-      if (glyphset.has (it->first))
+		 | hb_filter (glyphset, hb_first); it; ++it)
       {
 	from.push ()->set (glyph_map[it->first]);
 	to.push ()->set (glyph_map[it->second]);
@@ -343,16 +343,18 @@ struct MultipleSubstFormat1
 
   void closure (hb_closure_context_t *c) const
   {
-    for (auto it = hb_zip (this+coverage, sequence); it; ++it)
+    for (auto it = hb_zip (this+coverage, sequence)
-      if (c->glyphs->has (it->first))
+		 | hb_filter (*c->glyphs, hb_first)
-        (this+it->second).closure (c);
+		 | hb_map (hb_second); it; ++it)
+      (this+*it).closure (c);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   {
     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
-    for (auto it = hb_zip (this+coverage, sequence); it; ++it)
+    for (auto it = hb_zip (this+coverage, sequence)
-      (this+it->second).collect_glyphs (c);
+		 | hb_map (hb_second); it; ++it)
+      (this+*it).collect_glyphs (c);
   }
 
   const Coverage &get_coverage () const { return this+coverage; }
@@ -517,16 +519,17 @@ struct AlternateSubstFormat1
 
   void closure (hb_closure_context_t *c) const
   {
-    for (auto it = hb_zip (this+coverage, alternateSet); it; ++it)
+    for (auto it = hb_zip (this+coverage, alternateSet)
-      if (c->glyphs->has (it->first))
+		 | hb_map (hb_second); it; ++it)
-        (this+it->second).closure (c);
+      (this+*it).closure (c);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   {
     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
-    for (auto it = hb_zip (this+coverage, alternateSet); it; ++it)
+    for (auto it = hb_zip (this+coverage, alternateSet)
-      (this+it->second).collect_glyphs (c);
+		 | hb_map (hb_second); it; ++it)
+      (this+*it).collect_glyphs (c);
   }
 
   const Coverage &get_coverage () const { return this+coverage; }
@@ -823,25 +826,28 @@ struct LigatureSubstFormat1
 {
   bool intersects (const hb_set_t *glyphs) const
   {
-    for (auto it = hb_zip (this+coverage, ligatureSet); it; ++it)
+    for (auto it = hb_zip (this+coverage, ligatureSet)
-      if (glyphs->has (it->first))
+		 | hb_filter (*glyphs, hb_first)
-        if ((this+it->second).intersects (glyphs))
+		 | hb_map (hb_second); it; ++it)
-	  return true;
+      if ((this+*it).intersects (glyphs))
+	return true;
     return false;
   }
 
   void closure (hb_closure_context_t *c) const
   {
-    for (auto it = hb_zip (this+coverage, ligatureSet); it; ++it)
+    for (auto it = hb_zip (this+coverage, ligatureSet)
-      if (c->glyphs->has (it->first))
+		 | hb_filter (*c->glyphs, hb_first)
-        (this+it->second).closure (c);
+		 | hb_map (hb_second); it; ++it)
+      (this+*it).closure (c);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   {
     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
-    for (auto it = hb_zip (this+coverage, ligatureSet); it; ++it)
+    for (auto it = hb_zip (this+coverage, ligatureSet)
-      (this+it->second).collect_glyphs (c);
+		 | hb_map (hb_second); it; ++it)
+      (this+*it).collect_glyphs (c);
   }
 
   const Coverage &get_coverage () const { return this+coverage; }
@@ -1012,9 +1018,10 @@ struct ReverseChainSingleSubstFormat1
         return;
 
     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
-    for (auto it = hb_zip (this+coverage, substitute); it; ++it)
+    for (auto it = hb_zip (this+coverage, substitute)
-      if (c->glyphs->has (it->first))
+		 | hb_filter (*c->glyphs, hb_first)
-        c->output->add (it->second);
+		 | hb_map (hb_second); it; ++it)
+      c->output->add (*it);
   }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const