1 /* 2 * Copyright 2015 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkRecordPattern_DEFINED 9 #define SkRecordPattern_DEFINED 10 11 #include "SkRecord.h" 12 #include "SkTLogic.h" 13 14 namespace SkRecords { 15 16 // First, some matchers. These match a single command in the SkRecord, 17 // and may hang onto some data from it. If so, you can get the data by calling .get(). 18 19 // Matches a command of type T, and stores that command. 20 template <typename T> 21 class Is { 22 public: Is()23 Is() : fPtr(nullptr) {} 24 25 typedef T type; get()26 type* get() { return fPtr; } 27 operator()28 bool operator()(T* ptr) { 29 fPtr = ptr; 30 return true; 31 } 32 33 template <typename U> operator()34 bool operator()(U*) { 35 fPtr = nullptr; 36 return false; 37 } 38 39 private: 40 type* fPtr; 41 }; 42 43 // Matches any command that draws, and stores its paint. 44 class IsDraw { 45 public: IsDraw()46 IsDraw() : fPaint(nullptr) {} 47 48 typedef SkPaint type; get()49 type* get() { return fPaint; } 50 51 template <typename T> operator()52 SK_WHEN((T::kTags & kDrawWithPaint_Tag) == kDrawWithPaint_Tag, bool) operator()(T* draw) { 53 fPaint = AsPtr(draw->paint); 54 return true; 55 } 56 57 template <typename T> operator()58 SK_WHEN((T::kTags & kDrawWithPaint_Tag) == kDraw_Tag, bool) operator()(T* draw) { 59 fPaint = nullptr; 60 return true; 61 } 62 63 template <typename T> operator()64 SK_WHEN(!(T::kTags & kDraw_Tag), bool) operator()(T* draw) { 65 fPaint = nullptr; 66 return false; 67 } 68 69 private: 70 // Abstracts away whether the paint is always part of the command or optional. AsPtr(SkRecords::Optional<T> & x)71 template <typename T> static T* AsPtr(SkRecords::Optional<T>& x) { return x; } AsPtr(T & x)72 template <typename T> static T* AsPtr(T& x) { return &x; } 73 74 type* fPaint; 75 }; 76 77 // Matches if Matcher doesn't. Stores nothing. 78 template <typename Matcher> 79 struct Not { 80 template <typename T> operatorNot81 bool operator()(T* ptr) { return !Matcher()(ptr); } 82 }; 83 84 // Matches if any of First or Rest... does. Stores nothing. 85 template <typename First, typename... Rest> 86 struct Or { 87 template <typename T> operatorOr88 bool operator()(T* ptr) { return First()(ptr) || Or<Rest...>()(ptr); } 89 }; 90 template <typename First> 91 struct Or<First> { 92 template <typename T> 93 bool operator()(T* ptr) { return First()(ptr); } 94 }; 95 96 97 // Greedy is a special matcher that greedily matches Matcher 0 or more times. Stores nothing. 98 template <typename Matcher> 99 struct Greedy { 100 template <typename T> 101 bool operator()(T* ptr) { return Matcher()(ptr); } 102 }; 103 104 // Pattern matches each of its matchers in order. 105 // 106 // This is the main entry point to pattern matching, and so provides a couple of extra API bits: 107 // - search scans through the record to look for matches; 108 // - first, second, third, ... return the data stored by their respective matchers in the pattern. 109 110 template <typename... Matchers> class Pattern; 111 112 template <> class Pattern<> { 113 public: 114 // Bottoms out recursion. Just return whatever i the front decided on. 115 int match(SkRecord*, int i) { return i; } 116 }; 117 118 template <typename First, typename... Rest> 119 class Pattern<First, Rest...> { 120 public: 121 // If this pattern matches the SkRecord starting from i, 122 // return the index just past the end of the pattern, otherwise return 0. 123 SK_ALWAYS_INLINE int match(SkRecord* record, int i) { 124 i = this->matchFirst(&fFirst, record, i); 125 return i > 0 ? fRest.match(record, i) : 0; 126 } 127 128 // Starting from *end, walk through the SkRecord to find the first span matching this pattern. 129 // If there is no such span, return false. If there is, return true and set [*begin, *end). 130 SK_ALWAYS_INLINE bool search(SkRecord* record, int* begin, int* end) { 131 for (*begin = *end; *begin < record->count(); ++(*begin)) { 132 *end = this->match(record, *begin); 133 if (*end != 0) { 134 return true; 135 } 136 } 137 return false; 138 } 139 140 // TODO: some sort of smart get<i>() 141 template <typename T> T* first() { return fFirst.get(); } 142 template <typename T> T* second() { return fRest.template first<T>(); } 143 template <typename T> T* third() { return fRest.template second<T>(); } 144 template <typename T> T* fourth() { return fRest.template third<T>(); } 145 146 private: 147 // If first isn't a Greedy, try to match at i once. 148 template <typename T> 149 int matchFirst(T* first, SkRecord* record, int i) { 150 if (i < record->count()) { 151 if (record->mutate(i, *first)) { 152 return i+1; 153 } 154 } 155 return 0; 156 } 157 158 // If first is a Greedy, walk i until it doesn't match. 159 template <typename T> 160 int matchFirst(Greedy<T>* first, SkRecord* record, int i) { 161 while (i < record->count()) { 162 if (!record->mutate(i, *first)) { 163 return i; 164 } 165 i++; 166 } 167 return 0; 168 } 169 170 First fFirst; 171 Pattern<Rest...> fRest; 172 }; 173 174 } // namespace SkRecords 175 176 #endif//SkRecordPattern_DEFINED 177