/src/skia/tools/SkMetaData.cpp

Source (jump to first uncovered line)
/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "tools/SkMetaData.h"

#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTo.h"

void SkMetaData::reset()
{
    Rec* rec = fRec;
    while (rec) {
        Rec* next = rec->fNext;
        Rec::Free(rec);
        rec = next;
    }
    fRec = nullptr;
}

void SkMetaData::setS32(const char name[], int32_t value)
{
    (void)this->set(name, &value, sizeof(int32_t), kS32_Type, 1);
}

void SkMetaData::setScalar(const char name[], SkScalar value)
{
    (void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
}

SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
{
    SkASSERT(count > 0);
    if (count > 0)
        return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
    return nullptr;
}

void SkMetaData::setPtr(const char name[], void* ptr) {
    (void)this->set(name, &ptr, sizeof(void*), kPtr_Type, 1);
}

void SkMetaData::setBool(const char name[], bool value)
{
    (void)this->set(name, &value, sizeof(bool), kBool_Type, 1);
}

void* SkMetaData::set(const char name[], const void* data, size_t dataSize, Type type, int count)
{
    SkASSERT(name);
    SkASSERT(dataSize);
    SkASSERT(count > 0);

    FindResult result = this->findWithPrev(name, type);

    Rec* rec;
    bool reuseRec = result.rec &&
                    result.rec->fDataLen == dataSize &&
                    result.rec->fDataCount == count;
    if (reuseRec) {
        rec = result.rec;
    } else {
        size_t len = strlen(name);
        rec = Rec::Alloc(sizeof(Rec) + dataSize * count + len + 1);
        rec->fType = SkToU8(type);
        rec->fDataLen = SkToU8(dataSize);
        rec->fDataCount = SkToU16(count);

        memcpy(rec->name(), name, len + 1);
    }
    if (data) {
        memcpy(rec->data(), data, dataSize * count);
    }

    if (reuseRec) {
        // Do nothing, reused
    } else if (result.rec) {
        // Had one, but had to create a new one. Invalidates iterators.
        // Delayed removal since name or data may have been in the result.rec.
        this->remove(result);
        if (result.prev) {
            rec->fNext = result.prev->fNext;
            result.prev->fNext = rec;
        }
    } else {
        // Adding a new one, stick it at head.
        rec->fNext = fRec;
        fRec = rec;
    }
    return rec->data();
}

bool SkMetaData::findS32(const char name[], int32_t* value) const
{
    const Rec* rec = this->find(name, kS32_Type);
    if (rec)
    {
        SkASSERT(rec->fDataCount == 1);
        if (value)
            *value = *(const int32_t*)rec->data();
        return true;
    }
    return false;
}

bool SkMetaData::findScalar(const char name[], SkScalar* value) const
{
    const Rec* rec = this->find(name, kScalar_Type);
    if (rec)
    {
        SkASSERT(rec->fDataCount == 1);
        if (value)
            *value = *(const SkScalar*)rec->data();
        return true;
    }
    return false;
}

const SkScalar* SkMetaData::findScalars(const char name[], int* count, SkScalar values[]) const
{
    const Rec* rec = this->find(name, kScalar_Type);
    if (rec)
    {
        if (count)
            *count = rec->fDataCount;
        if (values)
            memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
        return (const SkScalar*)rec->data();
    }
    return nullptr;
}

bool SkMetaData::findPtr(const char name[], void** ptr) const {
    const Rec* rec = this->find(name, kPtr_Type);
    if (rec) {
        SkASSERT(rec->fDataCount == 1);
        void* const* found = (void* const*)rec->data();
        if (ptr) {
            *ptr = *found;
        }
        return true;
    }
    return false;
}

bool SkMetaData::findBool(const char name[], bool* value) const
{
    const Rec* rec = this->find(name, kBool_Type);
    if (rec)
    {
        SkASSERT(rec->fDataCount == 1);
        if (value)
            *value = *(const bool*)rec->data();
        return true;
    }
    return false;
}

SkMetaData::FindResult SkMetaData::findWithPrev(const char name[], Type type) const {
    FindResult current { fRec, nullptr };
    while (current.rec) {
        if (current.rec->fType == type && !strcmp(current.rec->name(), name))
            return current;
        current.prev = current.rec;
        current.rec = current.rec->fNext;
    }
    return current;
}


const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const {
    return this->findWithPrev(name, type).rec;
}

void SkMetaData::remove(FindResult result) {
    SkASSERT(result.rec);
    if (result.prev) {
        result.prev->fNext = result.rec->fNext;
    } else {
        fRec = result.rec->fNext;
    }
    Rec::Free(result.rec);
}

bool SkMetaData::remove(const char name[], Type type) {
    FindResult result = this->findWithPrev(name, type);
    if (!result.rec) {
        return false;
    }
    this->remove(result);
    return true;
}

bool SkMetaData::removeS32(const char name[])
{
    return this->remove(name, kS32_Type);
}

bool SkMetaData::removeScalar(const char name[])
{
    return this->remove(name, kScalar_Type);
}

bool SkMetaData::removePtr(const char name[])
{
    return this->remove(name, kPtr_Type);
}

bool SkMetaData::removeBool(const char name[])
{
    return this->remove(name, kBool_Type);
}

///////////////////////////////////////////////////////////////////////////////

SkMetaData::Iter::Iter(const SkMetaData& metadata) {
    fRec = metadata.fRec;
}

void SkMetaData::Iter::reset(const SkMetaData& metadata) {
    fRec = metadata.fRec;
}

const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
    const char* name = nullptr;

    if (fRec) {
        if (t) {
            *t = (SkMetaData::Type)fRec->fType;
        }
        if (count) {
            *count = fRec->fDataCount;
        }
        name = fRec->name();

        fRec = fRec->fNext;
    }
    return name;
}

///////////////////////////////////////////////////////////////////////////////

SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size) {
    return (Rec*)sk_malloc_throw(size);
}

void SkMetaData::Rec::Free(Rec* rec) {
    sk_free(rec);
}

Coverage Report

Created: 2024-05-20 07:14

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2006 The Android Open Source Project
3		*
4		* Use of this source code is governed by a BSD-style license that can be
5		* found in the LICENSE file.
6		*/
7
8		#include "tools/SkMetaData.h"
9
10		#include "include/private/base/SkMalloc.h"
11		#include "include/private/base/SkTo.h"
12
13		void SkMetaData::reset()
14	0	{
15	0	Rec* rec = fRec;
16	0	while (rec) {
17	0	Rec* next = rec->fNext;
18	0	Rec::Free(rec);
19	0	rec = next;
20	0	}
21	0	fRec = nullptr;
22	0	}
23
24		void SkMetaData::setS32(const char name[], int32_t value)
25	0	{
26	0	(void)this->set(name, &value, sizeof(int32_t), kS32_Type, 1);
27	0	}
28
29		void SkMetaData::setScalar(const char name[], SkScalar value)
30	0	{
31	0	(void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
32	0	}
33
34		SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
35	0	{
36	0	SkASSERT(count > 0);
37	0	if (count > 0)
38	0	return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
39	0	return nullptr;
40	0	} Unexecuted instantiation: SkMetaData::setScalars(char const, int, float const) Unexecuted instantiation: SkMetaData::setScalars(char const, int, float const)
41
42	0	void SkMetaData::setPtr(const char name[], void* ptr) {
43	0	(void)this->set(name, &ptr, sizeof(void*), kPtr_Type, 1);
44	0	}
45
46		void SkMetaData::setBool(const char name[], bool value)
47	0	{
48	0	(void)this->set(name, &value, sizeof(bool), kBool_Type, 1);
49	0	}
50
51		void* SkMetaData::set(const char name[], const void* data, size_t dataSize, Type type, int count)
52	0	{
53	0	SkASSERT(name);
54	0	SkASSERT(dataSize);
55	0	SkASSERT(count > 0);
56
57	0	FindResult result = this->findWithPrev(name, type);
58
59	0	Rec* rec;
60	0	bool reuseRec = result.rec &&
61	0	result.rec->fDataLen == dataSize &&
62	0	result.rec->fDataCount == count;
63	0	if (reuseRec) {
64	0	rec = result.rec;
65	0	} else {
66	0	size_t len = strlen(name);
67	0	rec = Rec::Alloc(sizeof(Rec) + dataSize * count + len + 1);
68	0	rec->fType = SkToU8(type);
69	0	rec->fDataLen = SkToU8(dataSize);
70	0	rec->fDataCount = SkToU16(count);
71
72	0	memcpy(rec->name(), name, len + 1);
73	0	}
74	0	if (data) {
75	0	memcpy(rec->data(), data, dataSize * count);
76	0	}
77
78	0	if (reuseRec) {
79		// Do nothing, reused
80	0	} else if (result.rec) {
81		// Had one, but had to create a new one. Invalidates iterators.
82		// Delayed removal since name or data may have been in the result.rec.
83	0	this->remove(result);
84	0	if (result.prev) {
85	0	rec->fNext = result.prev->fNext;
86	0	result.prev->fNext = rec;
87	0	}
88	0	} else {
89		// Adding a new one, stick it at head.
90	0	rec->fNext = fRec;
91	0	fRec = rec;
92	0	}
93	0	return rec->data();
94	0	} Unexecuted instantiation: SkMetaData::set(char const, void const, unsigned long, SkMetaData::Type, int) Unexecuted instantiation: SkMetaData::set(char const, void const, unsigned long, SkMetaData::Type, int)
95
96		bool SkMetaData::findS32(const char name[], int32_t* value) const
97	0	{
98	0	const Rec* rec = this->find(name, kS32_Type);
99	0	if (rec)
100	0	{
101	0	SkASSERT(rec->fDataCount == 1);
102	0	if (value)
103	0	value = (const int32_t*)rec->data();
104	0	return true;
105	0	}
106	0	return false;
107	0	} Unexecuted instantiation: SkMetaData::findS32(char const, int) const Unexecuted instantiation: SkMetaData::findS32(char const, int) const
108
109		bool SkMetaData::findScalar(const char name[], SkScalar* value) const
110	0	{
111	0	const Rec* rec = this->find(name, kScalar_Type);
112	0	if (rec)
113	0	{
114	0	SkASSERT(rec->fDataCount == 1);
115	0	if (value)
116	0	value = (const SkScalar*)rec->data();
117	0	return true;
118	0	}
119	0	return false;
120	0	} Unexecuted instantiation: SkMetaData::findScalar(char const, float) const Unexecuted instantiation: SkMetaData::findScalar(char const, float) const
121
122		const SkScalar* SkMetaData::findScalars(const char name[], int* count, SkScalar values[]) const
123	0	{
124	0	const Rec* rec = this->find(name, kScalar_Type);
125	0	if (rec)
126	0	{
127	0	if (count)
128	0	*count = rec->fDataCount;
129	0	if (values)
130	0	memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
131	0	return (const SkScalar*)rec->data();
132	0	}
133	0	return nullptr;
134	0	}
135
136	0	bool SkMetaData::findPtr(const char name[], void** ptr) const {
137	0	const Rec* rec = this->find(name, kPtr_Type);
138	0	if (rec) {
139	0	SkASSERT(rec->fDataCount == 1);
140	0	void* const* found = (void* const*)rec->data();
141	0	if (ptr) {
142	0	ptr = found;
143	0	}
144	0	return true;
145	0	}
146	0	return false;
147	0	} Unexecuted instantiation: SkMetaData::findPtr(char const, void) const Unexecuted instantiation: SkMetaData::findPtr(char const, void**) const
148
149		bool SkMetaData::findBool(const char name[], bool* value) const
150	0	{
151	0	const Rec* rec = this->find(name, kBool_Type);
152	0	if (rec)
153	0	{
154	0	SkASSERT(rec->fDataCount == 1);
155	0	if (value)
156	0	value = (const bool*)rec->data();
157	0	return true;
158	0	}
159	0	return false;
160	0	} Unexecuted instantiation: SkMetaData::findBool(char const, bool) const Unexecuted instantiation: SkMetaData::findBool(char const, bool) const
161
162	0	SkMetaData::FindResult SkMetaData::findWithPrev(const char name[], Type type) const {
163	0	FindResult current { fRec, nullptr };
164	0	while (current.rec) {
165	0	if (current.rec->fType == type && !strcmp(current.rec->name(), name))
166	0	return current;
167	0	current.prev = current.rec;
168	0	current.rec = current.rec->fNext;
169	0	}
170	0	return current;
171	0	}
172
173
174	0	const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const {
175	0	return this->findWithPrev(name, type).rec;
176	0	}
177
178	0	void SkMetaData::remove(FindResult result) {
179	0	SkASSERT(result.rec);
180	0	if (result.prev) {
181	0	result.prev->fNext = result.rec->fNext;
182	0	} else {
183	0	fRec = result.rec->fNext;
184	0	}
185	0	Rec::Free(result.rec);
186	0	} Unexecuted instantiation: SkMetaData::remove(SkMetaData::FindResult) Unexecuted instantiation: SkMetaData::remove(SkMetaData::FindResult)
187
188	0	bool SkMetaData::remove(const char name[], Type type) {
189	0	FindResult result = this->findWithPrev(name, type);
190	0	if (!result.rec) {
191	0	return false;
192	0	}
193	0	this->remove(result);
194	0	return true;
195	0	}
196
197		bool SkMetaData::removeS32(const char name[])
198	0	{
199	0	return this->remove(name, kS32_Type);
200	0	}
201
202		bool SkMetaData::removeScalar(const char name[])
203	0	{
204	0	return this->remove(name, kScalar_Type);
205	0	}
206
207		bool SkMetaData::removePtr(const char name[])
208	0	{
209	0	return this->remove(name, kPtr_Type);
210	0	}
211
212		bool SkMetaData::removeBool(const char name[])
213	0	{
214	0	return this->remove(name, kBool_Type);
215	0	}
216
217		///////////////////////////////////////////////////////////////////////////////
218
219	0	SkMetaData::Iter::Iter(const SkMetaData& metadata) {
220	0	fRec = metadata.fRec;
221	0	}
222
223	0	void SkMetaData::Iter::reset(const SkMetaData& metadata) {
224	0	fRec = metadata.fRec;
225	0	}
226
227	0	const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
228	0	const char* name = nullptr;
229
230	0	if (fRec) {
231	0	if (t) {
232	0	*t = (SkMetaData::Type)fRec->fType;
233	0	}
234	0	if (count) {
235	0	*count = fRec->fDataCount;
236	0	}
237	0	name = fRec->name();
238
239	0	fRec = fRec->fNext;
240	0	}
241	0	return name;
242	0	}
243
244		///////////////////////////////////////////////////////////////////////////////
245
246	0	SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size) {
247	0	return (Rec*)sk_malloc_throw(size);
248	0	}
249
250	0	void SkMetaData::Rec::Free(Rec* rec) {
251	0	sk_free(rec);
252	0	}