1 :
2 : /*
3 : * Copyright 2006 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 : #include "SkMetaData.h"
11 : #include "SkRefCnt.h"
12 :
13 : struct PtrPair {
14 : void* fPtr;
15 : SkMetaData::PtrProc fProc;
16 : };
17 :
18 0 : void* SkMetaData::RefCntProc(void* ptr, bool doRef) {
19 0 : SkASSERT(ptr);
20 0 : SkRefCnt* refcnt = reinterpret_cast<SkRefCnt*>(ptr);
21 :
22 0 : if (doRef) {
23 0 : refcnt->ref();
24 : } else {
25 0 : refcnt->unref();
26 : }
27 0 : return ptr;
28 : }
29 :
30 0 : SkMetaData::SkMetaData() : fRec(NULL)
31 : {
32 0 : }
33 :
34 0 : SkMetaData::SkMetaData(const SkMetaData& src) : fRec(NULL)
35 : {
36 0 : *this = src;
37 0 : }
38 :
39 0 : SkMetaData::~SkMetaData()
40 : {
41 0 : this->reset();
42 0 : }
43 :
44 0 : void SkMetaData::reset()
45 : {
46 0 : Rec* rec = fRec;
47 0 : while (rec) {
48 0 : if (kPtr_Type == rec->fType) {
49 0 : PtrPair* pair = (PtrPair*)rec->data();
50 0 : if (pair->fProc && pair->fPtr) {
51 0 : pair->fPtr = pair->fProc(pair->fPtr, false);
52 : }
53 : }
54 0 : Rec* next = rec->fNext;
55 0 : Rec::Free(rec);
56 0 : rec = next;
57 : }
58 0 : fRec = NULL;
59 0 : }
60 :
61 0 : SkMetaData& SkMetaData::operator=(const SkMetaData& src)
62 : {
63 0 : this->reset();
64 :
65 0 : const Rec* rec = src.fRec;
66 0 : while (rec)
67 : {
68 0 : this->set(rec->name(), rec->data(), rec->fDataLen, (Type)rec->fType, rec->fDataCount);
69 0 : rec = rec->fNext;
70 : }
71 0 : return *this;
72 : }
73 :
74 0 : void SkMetaData::setS32(const char name[], int32_t value)
75 : {
76 0 : (void)this->set(name, &value, sizeof(int32_t), kS32_Type, 1);
77 0 : }
78 :
79 0 : void SkMetaData::setScalar(const char name[], SkScalar value)
80 : {
81 0 : (void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
82 0 : }
83 :
84 0 : SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
85 : {
86 0 : SkASSERT(count > 0);
87 0 : if (count > 0)
88 0 : return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
89 0 : return NULL;
90 : }
91 :
92 0 : void SkMetaData::setString(const char name[], const char value[])
93 : {
94 0 : (void)this->set(name, value, sizeof(char), kString_Type, strlen(value) + 1);
95 0 : }
96 :
97 0 : void SkMetaData::setPtr(const char name[], void* ptr, PtrProc proc) {
98 0 : PtrPair pair = { ptr, proc };
99 0 : (void)this->set(name, &pair, sizeof(PtrPair), kPtr_Type, 1);
100 0 : }
101 :
102 0 : void SkMetaData::setBool(const char name[], bool value)
103 : {
104 0 : (void)this->set(name, &value, sizeof(bool), kBool_Type, 1);
105 0 : }
106 :
107 0 : void SkMetaData::setData(const char name[], const void* data, size_t byteCount) {
108 0 : (void)this->set(name, data, sizeof(char), kData_Type, byteCount);
109 0 : }
110 :
111 0 : void* SkMetaData::set(const char name[], const void* data, size_t dataSize, Type type, int count)
112 : {
113 0 : SkASSERT(name);
114 0 : SkASSERT(dataSize);
115 0 : SkASSERT(count > 0);
116 :
117 0 : (void)this->remove(name, type);
118 :
119 0 : size_t len = strlen(name);
120 0 : Rec* rec = Rec::Alloc(sizeof(Rec) + dataSize * count + len + 1);
121 :
122 : #ifndef SK_DEBUG
123 : rec->fType = SkToU8(type);
124 : #else
125 0 : rec->fType = type;
126 : #endif
127 0 : rec->fDataLen = SkToU8(dataSize);
128 0 : rec->fDataCount = SkToU16(count);
129 0 : if (data)
130 0 : memcpy(rec->data(), data, dataSize * count);
131 0 : memcpy(rec->name(), name, len + 1);
132 :
133 0 : if (kPtr_Type == type) {
134 0 : PtrPair* pair = (PtrPair*)rec->data();
135 0 : if (pair->fProc && pair->fPtr) {
136 0 : pair->fPtr = pair->fProc(pair->fPtr, true);
137 : }
138 : }
139 :
140 0 : rec->fNext = fRec;
141 0 : fRec = rec;
142 0 : return rec->data();
143 : }
144 :
145 0 : bool SkMetaData::findS32(const char name[], int32_t* value) const
146 : {
147 0 : const Rec* rec = this->find(name, kS32_Type);
148 0 : if (rec)
149 : {
150 0 : SkASSERT(rec->fDataCount == 1);
151 0 : if (value)
152 0 : *value = *(const int32_t*)rec->data();
153 0 : return true;
154 : }
155 0 : return false;
156 : }
157 :
158 0 : bool SkMetaData::findScalar(const char name[], SkScalar* value) const
159 : {
160 0 : const Rec* rec = this->find(name, kScalar_Type);
161 0 : if (rec)
162 : {
163 0 : SkASSERT(rec->fDataCount == 1);
164 0 : if (value)
165 0 : *value = *(const SkScalar*)rec->data();
166 0 : return true;
167 : }
168 0 : return false;
169 : }
170 :
171 0 : const SkScalar* SkMetaData::findScalars(const char name[], int* count, SkScalar values[]) const
172 : {
173 0 : const Rec* rec = this->find(name, kScalar_Type);
174 0 : if (rec)
175 : {
176 0 : if (count)
177 0 : *count = rec->fDataCount;
178 0 : if (values)
179 0 : memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
180 0 : return (const SkScalar*)rec->data();
181 : }
182 0 : return NULL;
183 : }
184 :
185 0 : bool SkMetaData::findPtr(const char name[], void** ptr, PtrProc* proc) const {
186 0 : const Rec* rec = this->find(name, kPtr_Type);
187 0 : if (rec) {
188 0 : SkASSERT(rec->fDataCount == 1);
189 0 : const PtrPair* pair = (const PtrPair*)rec->data();
190 0 : if (ptr) {
191 0 : *ptr = pair->fPtr;
192 : }
193 0 : if (proc) {
194 0 : *proc = pair->fProc;
195 : }
196 0 : return true;
197 : }
198 0 : return false;
199 : }
200 :
201 0 : const char* SkMetaData::findString(const char name[]) const
202 : {
203 0 : const Rec* rec = this->find(name, kString_Type);
204 0 : SkASSERT(rec == NULL || rec->fDataLen == sizeof(char));
205 0 : return rec ? (const char*)rec->data() : NULL;
206 : }
207 :
208 0 : bool SkMetaData::findBool(const char name[], bool* value) const
209 : {
210 0 : const Rec* rec = this->find(name, kBool_Type);
211 0 : if (rec)
212 : {
213 0 : SkASSERT(rec->fDataCount == 1);
214 0 : if (value)
215 0 : *value = *(const bool*)rec->data();
216 0 : return true;
217 : }
218 0 : return false;
219 : }
220 :
221 0 : const void* SkMetaData::findData(const char name[], size_t* length) const {
222 0 : const Rec* rec = this->find(name, kData_Type);
223 0 : if (rec) {
224 0 : SkASSERT(rec->fDataLen == sizeof(char));
225 0 : if (length) {
226 0 : *length = rec->fDataCount;
227 : }
228 0 : return rec->data();
229 : }
230 0 : return NULL;
231 : }
232 :
233 0 : const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const
234 : {
235 0 : const Rec* rec = fRec;
236 0 : while (rec)
237 : {
238 0 : if (rec->fType == type && !strcmp(rec->name(), name))
239 0 : return rec;
240 0 : rec = rec->fNext;
241 : }
242 0 : return NULL;
243 : }
244 :
245 0 : bool SkMetaData::remove(const char name[], Type type) {
246 0 : Rec* rec = fRec;
247 0 : Rec* prev = NULL;
248 0 : while (rec) {
249 0 : Rec* next = rec->fNext;
250 0 : if (rec->fType == type && !strcmp(rec->name(), name)) {
251 0 : if (prev) {
252 0 : prev->fNext = next;
253 : } else {
254 0 : fRec = next;
255 : }
256 :
257 0 : if (kPtr_Type == type) {
258 0 : PtrPair* pair = (PtrPair*)rec->data();
259 0 : if (pair->fProc && pair->fPtr) {
260 0 : (void)pair->fProc(pair->fPtr, false);
261 : }
262 : }
263 0 : Rec::Free(rec);
264 0 : return true;
265 : }
266 0 : prev = rec;
267 0 : rec = next;
268 : }
269 0 : return false;
270 : }
271 :
272 0 : bool SkMetaData::removeS32(const char name[])
273 : {
274 0 : return this->remove(name, kS32_Type);
275 : }
276 :
277 0 : bool SkMetaData::removeScalar(const char name[])
278 : {
279 0 : return this->remove(name, kScalar_Type);
280 : }
281 :
282 0 : bool SkMetaData::removeString(const char name[])
283 : {
284 0 : return this->remove(name, kString_Type);
285 : }
286 :
287 0 : bool SkMetaData::removePtr(const char name[])
288 : {
289 0 : return this->remove(name, kPtr_Type);
290 : }
291 :
292 0 : bool SkMetaData::removeBool(const char name[])
293 : {
294 0 : return this->remove(name, kBool_Type);
295 : }
296 :
297 0 : bool SkMetaData::removeData(const char name[]) {
298 0 : return this->remove(name, kData_Type);
299 : }
300 :
301 : ///////////////////////////////////////////////////////////////////////////////
302 :
303 0 : SkMetaData::Iter::Iter(const SkMetaData& metadata) {
304 0 : fRec = metadata.fRec;
305 0 : }
306 :
307 0 : void SkMetaData::Iter::reset(const SkMetaData& metadata) {
308 0 : fRec = metadata.fRec;
309 0 : }
310 :
311 0 : const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
312 0 : const char* name = NULL;
313 :
314 0 : if (fRec) {
315 0 : if (t) {
316 0 : *t = (SkMetaData::Type)fRec->fType;
317 : }
318 0 : if (count) {
319 0 : *count = fRec->fDataCount;
320 : }
321 0 : name = fRec->name();
322 :
323 0 : fRec = fRec->fNext;
324 : }
325 0 : return name;
326 : }
327 :
328 : ///////////////////////////////////////////////////////////////////////////////
329 :
330 0 : SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size) {
331 0 : return (Rec*)sk_malloc_throw(size);
332 : }
333 :
334 0 : void SkMetaData::Rec::Free(Rec* rec) {
335 0 : sk_free(rec);
336 0 : }
337 :
|