Line data Source code
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 : #ifndef SkMetaData_DEFINED
11 : #define SkMetaData_DEFINED
12 :
13 : #include "SkScalar.h"
14 :
15 : class SkRefCnt;
16 :
17 : class SK_API SkMetaData {
18 : public:
19 : /**
20 : * Used to manage the life-cycle of a ptr in the metadata. This is option
21 : * in setPtr, and is only invoked when either copying one metadata to
22 : * another, or when the metadata is destroyed.
23 : *
24 : * setPtr(name, ptr, proc) {
25 : * fPtr = proc(ptr, true);
26 : * }
27 : *
28 : * copy: A = B {
29 : * A.fPtr = B.fProc(B.fPtr, true);
30 : * }
31 : *
32 : * ~SkMetaData {
33 : * fProc(fPtr, false);
34 : * }
35 : */
36 : typedef void* (*PtrProc)(void* ptr, bool doRef);
37 :
38 : /**
39 : * Implements PtrProc for SkRefCnt pointers
40 : */
41 : static void* RefCntProc(void* ptr, bool doRef);
42 :
43 : SkMetaData();
44 : SkMetaData(const SkMetaData& src);
45 : ~SkMetaData();
46 :
47 : SkMetaData& operator=(const SkMetaData& src);
48 :
49 : void reset();
50 :
51 : bool findS32(const char name[], int32_t* value = NULL) const;
52 : bool findScalar(const char name[], SkScalar* value = NULL) const;
53 : const SkScalar* findScalars(const char name[], int* count,
54 : SkScalar values[] = NULL) const;
55 : const char* findString(const char name[]) const;
56 : bool findPtr(const char name[], void** value = NULL, PtrProc* = NULL) const;
57 : bool findBool(const char name[], bool* value = NULL) const;
58 : const void* findData(const char name[], size_t* byteCount = NULL) const;
59 :
60 : bool hasS32(const char name[], int32_t value) const {
61 : int32_t v;
62 : return this->findS32(name, &v) && v == value;
63 : }
64 : bool hasScalar(const char name[], SkScalar value) const {
65 : SkScalar v;
66 : return this->findScalar(name, &v) && v == value;
67 : }
68 : bool hasString(const char name[], const char value[]) const {
69 : const char* v = this->findString(name);
70 : return (v == NULL && value == NULL) ||
71 : (v != NULL && value != NULL && !strcmp(v, value));
72 : }
73 : bool hasPtr(const char name[], void* value) const {
74 : void* v;
75 : return this->findPtr(name, &v) && v == value;
76 : }
77 : bool hasBool(const char name[], bool value) const {
78 : bool v;
79 : return this->findBool(name, &v) && v == value;
80 : }
81 : bool hasData(const char name[], const void* data, size_t byteCount) const {
82 : size_t len;
83 : const void* ptr = this->findData(name, &len);
84 : return ptr && len == byteCount && !memcmp(ptr, data, len);
85 : }
86 :
87 : void setS32(const char name[], int32_t value);
88 : void setScalar(const char name[], SkScalar value);
89 : SkScalar* setScalars(const char name[], int count, const SkScalar values[] = NULL);
90 : void setString(const char name[], const char value[]);
91 : void setPtr(const char name[], void* value, PtrProc proc = NULL);
92 : void setBool(const char name[], bool value);
93 : // the data is copied from the input pointer.
94 : void setData(const char name[], const void* data, size_t byteCount);
95 :
96 : bool removeS32(const char name[]);
97 : bool removeScalar(const char name[]);
98 : bool removeString(const char name[]);
99 : bool removePtr(const char name[]);
100 : bool removeBool(const char name[]);
101 : bool removeData(const char name[]);
102 :
103 : // helpers for SkRefCnt
104 : bool findRefCnt(const char name[], SkRefCnt** ptr = NULL) {
105 : return this->findPtr(name, reinterpret_cast<void**>(ptr));
106 : }
107 : bool hasRefCnt(const char name[], SkRefCnt* ptr) {
108 : return this->hasPtr(name, ptr);
109 : }
110 : void setRefCnt(const char name[], SkRefCnt* ptr) {
111 : this->setPtr(name, ptr, RefCntProc);
112 : }
113 : bool removeRefCnt(const char name[]) {
114 : return this->removePtr(name);
115 : }
116 :
117 : enum Type {
118 : kS32_Type,
119 : kScalar_Type,
120 : kString_Type,
121 : kPtr_Type,
122 : kBool_Type,
123 : kData_Type,
124 :
125 : kTypeCount
126 : };
127 :
128 : struct Rec;
129 : class Iter;
130 : friend class Iter;
131 :
132 : class Iter {
133 : public:
134 : Iter() : fRec(NULL) {}
135 : Iter(const SkMetaData&);
136 :
137 : /** Reset the iterator, so that calling next() will return the first
138 : data element. This is done implicitly in the constructor.
139 : */
140 : void reset(const SkMetaData&);
141 :
142 : /** Each time next is called, it returns the name of the next data element,
143 : or null when there are no more elements. If non-null is returned, then the
144 : element's type is returned (if not null), and the number of data values
145 : is returned in count (if not null).
146 : */
147 : const char* next(Type*, int* count);
148 :
149 : private:
150 : Rec* fRec;
151 : };
152 :
153 : public:
154 : struct Rec {
155 : Rec* fNext;
156 : uint16_t fDataCount; // number of elements
157 : uint8_t fDataLen; // sizeof a single element
158 : uint8_t fType;
159 :
160 0 : const void* data() const { return (this + 1); }
161 0 : void* data() { return (this + 1); }
162 0 : const char* name() const { return (const char*)this->data() + fDataLen * fDataCount; }
163 0 : char* name() { return (char*)this->data() + fDataLen * fDataCount; }
164 :
165 : static Rec* Alloc(size_t);
166 : static void Free(Rec*);
167 : };
168 : Rec* fRec;
169 :
170 : const Rec* find(const char name[], Type) const;
171 : void* set(const char name[], const void* data, size_t len, Type, int count);
172 : bool remove(const char name[], Type);
173 : };
174 :
175 : #endif
|
