/* * Copyright 2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef SkRecordPattern_DEFINED #define SkRecordPattern_DEFINED #include "include/private/SkTLogic.h" #include "src/core/SkRecord.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(). // Matches a command of type T, and stores that command. template class Is { public: Is() : fPtr(nullptr) {} typedef T type; type* get() { return fPtr; } bool operator()(T* ptr) { fPtr = ptr; return true; } template bool operator()(U*) { fPtr = nullptr; return false; } private: type* fPtr; }; // Matches any command that draws, and stores its paint. class IsDraw { public: IsDraw() : fPaint(nullptr) {} typedef SkPaint type; type* get() { return fPaint; } template SK_WHEN((T::kTags & kDrawWithPaint_Tag) == kDrawWithPaint_Tag, bool) operator()(T* draw) { fPaint = AsPtr(draw->paint); return true; } template SK_WHEN((T::kTags & kDrawWithPaint_Tag) == kDraw_Tag, bool) operator()(T* draw) { fPaint = nullptr; return true; } template SK_WHEN(!(T::kTags & kDraw_Tag), bool) operator()(T* draw) { fPaint = nullptr; return false; } private: // Abstracts away whether the paint is always part of the command or optional. template static T* AsPtr(SkRecords::Optional& x) { return x; } template static T* AsPtr(T& x) { return &x; } type* fPaint; }; // Matches if Matcher doesn't. Stores nothing. template struct Not { template bool operator()(T* ptr) { return !Matcher()(ptr); } }; // Matches if any of First or Rest... does. Stores nothing. template struct Or { template bool operator()(T* ptr) { return First()(ptr) || Or()(ptr); } }; template struct Or { template bool operator()(T* ptr) { return First()(ptr); } }; // Greedy is a special matcher that greedily matches Matcher 0 or more times. Stores nothing. template struct Greedy { template bool operator()(T* ptr) { return Matcher()(ptr); } }; // Pattern matches each of its matchers in order. // // 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, third, ... return the data stored by their respective matchers in the pattern. template class Pattern; template <> class Pattern<> { public: // Bottoms out recursion. Just return whatever i the front decided on. int match(SkRecord*, int i) { return i; } }; template class Pattern { public: // If this pattern matches the SkRecord starting from i, // return the index just past the end of the pattern, otherwise return 0. SK_ALWAYS_INLINE int match(SkRecord* record, int i) { i = this->matchFirst(&fFirst, record, i); return i > 0 ? fRest.match(record, i) : 0; } // Starting from *end, walk through the SkRecord to find the first span matching this pattern. // If there is no such span, return false. If there is, return true and set [*begin, *end). SK_ALWAYS_INLINE bool search(SkRecord* record, int* begin, int* end) { for (*begin = *end; *begin < record->count(); ++(*begin)) { *end = this->match(record, *begin); if (*end != 0) { return true; } } return false; } // TODO: some sort of smart get() template T* first() { return fFirst.get(); } template T* second() { return fRest.template first(); } template T* third() { return fRest.template second(); } template T* fourth() { return fRest.template third(); } private: // If first isn't a Greedy, try to match at i once. template int matchFirst(T* first, SkRecord* record, int i) { if (i < record->count()) { if (record->mutate(i, *first)) { return i+1; } } return 0; } // If first is a Greedy, walk i until it doesn't match. template int matchFirst(Greedy* first, SkRecord* record, int i) { while (i < record->count()) { if (!record->mutate(i, *first)) { return i; } i++; } return 0; } First fFirst; Pattern fRest; }; } // namespace SkRecords #endif//SkRecordPattern_DEFINED