The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/core/SkPtrRecorder.h
gfx/skia/trunk/src/core/SkPtrRecorder.h
- branch
- TOR_BUG_9701
- changeset 9
- a63d609f5ebe
equal
deleted
inserted
replaced
| -1:000000000000 | 0:0a37a5ff4c36 |
|---|---|
| 1 | |
| 2 /* | |
| 3 * Copyright 2008 The Android Open Source Project | |
| 4 * | |
| 5 * Use of this source code is governed by a BSD-style license that can be | |
| 6 * found in the LICENSE file. | |
| 7 */ | |
| 8 | |
| 9 | |
| 10 #ifndef SkPtrSet_DEFINED | |
| 11 #define SkPtrSet_DEFINED | |
| 12 | |
| 13 #include "SkRefCnt.h" | |
| 14 #include "SkFlattenable.h" | |
| 15 #include "SkTDArray.h" | |
| 16 | |
| 17 /** | |
| 18 * Maintains a set of ptrs, assigning each a unique ID [1...N]. Duplicate ptrs | |
| 19 * return the same ID (since its a set). Subclasses can override inPtr() | |
| 20 * and decPtr(). incPtr() is called each time a unique ptr is added ot the | |
| 21 * set. decPtr() is called on each ptr when the set is destroyed or reset. | |
| 22 */ | |
| 23 class SkPtrSet : public SkRefCnt { | |
| 24 public: | |
| 25 SK_DECLARE_INST_COUNT(SkPtrSet) | |
| 26 | |
| 27 /** | |
| 28 * Search for the specified ptr in the set. If it is found, return its | |
| 29 * 32bit ID [1..N], or if not found, return 0. Always returns 0 for NULL. | |
| 30 */ | |
| 31 uint32_t find(void*) const; | |
| 32 | |
| 33 /** | |
| 34 * Add the specified ptr to the set, returning a unique 32bit ID for it | |
| 35 * [1...N]. Duplicate ptrs will return the same ID. | |
| 36 * | |
| 37 * If the ptr is NULL, it is not added, and 0 is returned. | |
| 38 */ | |
| 39 uint32_t add(void*); | |
| 40 | |
| 41 /** | |
| 42 * Return the number of (non-null) ptrs in the set. | |
| 43 */ | |
| 44 int count() const { return fList.count(); } | |
| 45 | |
| 46 /** | |
| 47 * Copy the ptrs in the set into the specified array (allocated by the | |
| 48 * caller). The ptrs are assgined to the array based on their corresponding | |
| 49 * ID. e.g. array[ptr.ID - 1] = ptr. | |
| 50 * | |
| 51 * incPtr() and decPtr() are not called during this operation. | |
| 52 */ | |
| 53 void copyToArray(void* array[]) const; | |
| 54 | |
| 55 /** | |
| 56 * Call decPtr() on each ptr in the set, and the reset the size of the set | |
| 57 * to 0. | |
| 58 */ | |
| 59 void reset(); | |
| 60 | |
| 61 protected: | |
| 62 virtual void incPtr(void*) {} | |
| 63 virtual void decPtr(void*) {} | |
| 64 | |
| 65 private: | |
| 66 struct Pair { | |
| 67 void* fPtr; // never NULL | |
| 68 uint32_t fIndex; // 1...N | |
| 69 }; | |
| 70 | |
| 71 // we store the ptrs in sorted-order (using Cmp) so that we can efficiently | |
| 72 // detect duplicates when add() is called. Hence we need to store the | |
| 73 // ptr and its ID/fIndex explicitly, since the ptr's position in the array | |
| 74 // is not related to its "index". | |
| 75 SkTDArray<Pair> fList; | |
| 76 | |
| 77 static bool Less(const Pair& a, const Pair& b); | |
| 78 | |
| 79 typedef SkRefCnt INHERITED; | |
| 80 }; | |
| 81 | |
| 82 /** | |
| 83 * Templated wrapper for SkPtrSet, just meant to automate typecasting | |
| 84 * parameters to and from void* (which the base class expects). | |
| 85 */ | |
| 86 template <typename T> class SkTPtrSet : public SkPtrSet { | |
| 87 public: | |
| 88 uint32_t find(T ptr) { | |
| 89 return this->INHERITED::find((void*)ptr); | |
| 90 } | |
| 91 uint32_t add(T ptr) { | |
| 92 return this->INHERITED::add((void*)ptr); | |
| 93 } | |
| 94 | |
| 95 void copyToArray(T* array) const { | |
| 96 this->INHERITED::copyToArray((void**)array); | |
| 97 } | |
| 98 | |
| 99 private: | |
| 100 typedef SkPtrSet INHERITED; | |
| 101 }; | |
| 102 | |
| 103 /** | |
| 104 * Subclass of SkTPtrSet specialed to call ref() and unref() when the | |
| 105 * base class's incPtr() and decPtr() are called. This makes it a valid owner | |
| 106 * of each ptr, which is released when the set is reset or destroyed. | |
| 107 */ | |
| 108 class SkRefCntSet : public SkTPtrSet<SkRefCnt*> { | |
| 109 public: | |
| 110 virtual ~SkRefCntSet(); | |
| 111 | |
| 112 protected: | |
| 113 // overrides | |
| 114 virtual void incPtr(void*); | |
| 115 virtual void decPtr(void*); | |
| 116 }; | |
| 117 | |
| 118 class SkFactorySet : public SkTPtrSet<SkFlattenable::Factory> {}; | |
| 119 | |
| 120 /** | |
| 121 * Similar to SkFactorySet, but only allows Factorys that have registered names. | |
| 122 * Also has a function to return the next added Factory's name. | |
| 123 */ | |
| 124 class SkNamedFactorySet : public SkRefCnt { | |
| 125 public: | |
| 126 SK_DECLARE_INST_COUNT(SkNamedFactorySet) | |
| 127 | |
| 128 SkNamedFactorySet(); | |
| 129 | |
| 130 /** | |
| 131 * Find the specified Factory in the set. If it is not already in the set, | |
| 132 * and has registered its name, add it to the set, and return its index. | |
| 133 * If the Factory has no registered name, return 0. | |
| 134 */ | |
| 135 uint32_t find(SkFlattenable::Factory); | |
| 136 | |
| 137 /** | |
| 138 * If new Factorys have been added to the set, return the name of the first | |
| 139 * Factory added after the Factory name returned by the last call to this | |
| 140 * function. | |
| 141 */ | |
| 142 const char* getNextAddedFactoryName(); | |
| 143 private: | |
| 144 int fNextAddedFactory; | |
| 145 SkFactorySet fFactorySet; | |
| 146 SkTDArray<const char*> fNames; | |
| 147 | |
| 148 typedef SkRefCnt INHERITED; | |
| 149 }; | |
| 150 | |
| 151 #endif |
