Split Star into Star (stores nothing) and List (stores matches).

src/record/SkRecordPattern.h

 #ifndef SkRecordPattern_DEFINED
 #define SkRecordPattern_DEFINED
 
 #include "SkTLogic.h"
 
 namespace SkRecords {
 
 // First, some matchers.  These match a single command in the SkRecord,
 // and may hang onto some data from it.  If so, you can get the data by calling .get().
 
@@ skipping 67 matching lines @@
 template <typename A, typename B>
 struct Or {
     template <typename T>
     bool operator()(T* ptr) { return A()(ptr) || B()(ptr); }
 };
 
 // Matches if any of A, B or C does.  Stores nothing.
 template <typename A, typename B, typename C>
 struct Or3 : Or<A, Or<B, C> > {};
 
-// We'll use this to choose which implementation of Star suits each Matcher.
-SK_CREATE_TYPE_DETECTOR(type);
-
-// Star is a special matcher that matches Matcher 0 or more times _greedily_ in the SkRecord.
-// This version stores nothing.  It's enabled when Matcher stores nothing.
-template <typename Matcher, typename = void>
-class Star {
-public:
-    void reset() {}
-
+// Star is a special matcher that greedily matches Matcher 0 or more times.  Stores nothing.
+template <typename Matcher>
+struct Star {
     template <typename T>
     bool operator()(T* ptr) { return Matcher()(ptr); }
 };
 
-// This version stores a list of matches.  It's enabled if Matcher stores something.
-template <typename Matcher>
-class Star<Matcher, SK_WHEN(HasType_type<Matcher>, void)> {
-public:
-    typedef SkTDArray<typename Matcher::type*> type;
-    type* get() { return &fMatches; }
-
-    void reset() { fMatches.rewind(); }
-
-    template <typename T>
-    bool operator()(T* ptr) {
-        Matcher matcher;
-        if (matcher(ptr)) {
-            fMatches.push(matcher.get());
-            return true;
-        }
-        return false;
-    }
-
-private:
-    type fMatches;
-};
-
-
 // Cons builds a list of Matchers.
 // It first matches Matcher (something from above), then Pattern (another Cons or Nil).
 //
 // This is the main entry point to pattern matching, and so provides a couple of extra API bits:
 //  - search scans through the record to look for matches;
 //  - first, second, and third return the data stored by their respective matchers in the pattern.
 //
 // These Cons build lists analogously to Lisp's "cons".  See Pattern# for the "list" equivalent.
 template <typename Matcher, typename Pattern>
 class Cons {
@@ skipping 32 matching lines @@
             if (record->mutate<bool>(i, fHead)) {
                 return i+1;
             }
         }
         return 0;
     }
 
     // If head is a Star, walk i until it doesn't match.
     template <typename T>
     unsigned matchHead(Star<T>*, SkRecord* record, unsigned i) {
-        fHead.reset();
         while (i < record->count()) {
             if (!record->mutate<bool>(i, fHead)) {
                 return i;
             }
             i++;
         }
         return 0;
     }
 
     Matcher fHead;
@@ skipping 17 matching lines @@
 
 template <typename A, typename B>
 struct Pattern2 : Cons<A, Pattern1<B> > {};
 
 template <typename A, typename B, typename C>
 struct Pattern3 : Cons<A, Pattern2<B, C> > {};
 
 }  // namespace SkRecords
 
 #endif//SkRecordPattern_DEFINED