00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef SkTemplates_DEFINED
00018 #define SkTemplates_DEFINED
00019
00020 #include "SkTypes.h"
00021
00036 template <typename T, void (*P)(T*)> class SkAutoTCallVProc : SkNoncopyable {
00037 public:
00038 SkAutoTCallVProc(T* obj): fObj(obj) {}
00039 ~SkAutoTCallVProc() { if (fObj) P(fObj); }
00040 T* detach() { T* obj = fObj; fObj = NULL; return obj; }
00041 private:
00042 T* fObj;
00043 };
00044
00053 template <typename T, int (*P)(T*)> class SkAutoTCallIProc : SkNoncopyable {
00054 public:
00055 SkAutoTCallIProc(T* obj): fObj(obj) {}
00056 ~SkAutoTCallIProc() { if (fObj) P(fObj); }
00057 T* detach() { T* obj = fObj; fObj = NULL; return obj; }
00058 private:
00059 T* fObj;
00060 };
00061
00062 template <typename T> class SkAutoTDelete : SkNoncopyable {
00063 public:
00064 SkAutoTDelete(T* obj) : fObj(obj) {}
00065 ~SkAutoTDelete() { delete fObj; }
00066
00067 T* get() const { return fObj; }
00068 void free() { delete fObj; fObj = NULL; }
00069 T* detach() { T* obj = fObj; fObj = NULL; return obj; }
00070
00071 private:
00072 T* fObj;
00073 };
00074
00075 template <typename T> class SkAutoTDeleteArray : SkNoncopyable {
00076 public:
00077 SkAutoTDeleteArray(T array[]) : fArray(array) {}
00078 ~SkAutoTDeleteArray() { delete[] fArray; }
00079
00080 T* get() const { return fArray; }
00081 void free() { delete[] fArray; fArray = NULL; }
00082 T* detach() { T* array = fArray; fArray = NULL; return array; }
00083
00084 private:
00085 T* fArray;
00086 };
00087
00090 template <typename T> class SkAutoTArray : SkNoncopyable {
00091 public:
00094 SkAutoTArray(size_t count) {
00095 fArray = NULL;
00096 if (count) {
00097 fArray = new T[count];
00098 }
00099 SkDEBUGCODE(fCount = count;)
00100 }
00101
00102 ~SkAutoTArray() {
00103 delete[] fArray;
00104 }
00105
00108 T* get() const { return fArray; }
00109
00112 T& operator[](int index) const {
00113 SkASSERT((unsigned)index < fCount);
00114 return fArray[index];
00115 }
00116
00117 private:
00118 T* fArray;
00119 SkDEBUGCODE(size_t fCount;)
00120 };
00121
00124 template <size_t N, typename T> class SkAutoSTArray : SkNoncopyable {
00125 public:
00128 SkAutoSTArray(size_t count) {
00129 if (count > N) {
00130 fArray = new T[count];
00131 } else if (count) {
00132 fArray = new (fStorage) T[count];
00133 } else {
00134 fArray = NULL;
00135 }
00136 fCount = count;
00137 }
00138
00139 ~SkAutoSTArray() {
00140 if (fCount > N) {
00141 delete[] fArray;
00142 } else {
00143 T* start = fArray;
00144 T* iter = start + fCount;
00145 while (iter > start) {
00146 (--iter)->~T();
00147 }
00148 }
00149 }
00150
00153 size_t count() const { return fCount; }
00154
00157 T* get() const { return fArray; }
00158
00161 T& operator[](int index) const {
00162 SkASSERT((unsigned)index < fCount);
00163 return fArray[index];
00164 }
00165
00166 private:
00167 size_t fCount;
00168 T* fArray;
00169
00170 char fStorage[N * sizeof(T)];
00171 };
00172
00176 template <typename T> class SkAutoTMalloc : SkNoncopyable {
00177 public:
00178 SkAutoTMalloc(size_t count)
00179 {
00180 fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
00181 }
00182 ~SkAutoTMalloc()
00183 {
00184 sk_free(fPtr);
00185 }
00186 T* get() const { return fPtr; }
00187
00188 private:
00189 T* fPtr;
00190 };
00191
00192 template <size_t N, typename T> class SkAutoSTMalloc : SkNoncopyable {
00193 public:
00194 SkAutoSTMalloc(size_t count)
00195 {
00196 if (count <= N)
00197 fPtr = fTStorage;
00198 else
00199 fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP);
00200 }
00201 ~SkAutoSTMalloc()
00202 {
00203 if (fPtr != fTStorage)
00204 sk_free(fPtr);
00205 }
00206 T* get() const { return fPtr; }
00207
00208 private:
00209 T* fPtr;
00210 union {
00211 uint32_t fStorage32[(N*sizeof(T) + 3) >> 2];
00212 T fTStorage[1];
00213 };
00214 };
00215
00216 #endif
00217