]>
Commit | Line | Data |
---|---|---|
fb08dde0 | 1 | /* |
41836a9f | 2 | * QDict Module |
fb08dde0 LC |
3 | * |
4 | * Copyright (C) 2009 Red Hat Inc. | |
5 | * | |
6 | * Authors: | |
7 | * Luiz Capitulino <lcapitulino@redhat.com> | |
8 | * | |
41836a9f LC |
9 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. |
10 | * See the COPYING.LIB file in the top-level directory. | |
fb08dde0 LC |
11 | */ |
12 | ||
f2ad72b3 | 13 | #include "qemu/osdep.h" |
01b2ffce | 14 | #include "qapi/qmp/qnum.h" |
7b1b5d19 PB |
15 | #include "qapi/qmp/qdict.h" |
16 | #include "qapi/qmp/qbool.h" | |
15280c36 | 17 | #include "qapi/qmp/qnull.h" |
7b1b5d19 | 18 | #include "qapi/qmp/qstring.h" |
80d71121 | 19 | #include "qobject-internal.h" |
fb08dde0 | 20 | |
fb08dde0 LC |
21 | /** |
22 | * qdict_new(): Create a new QDict | |
23 | * | |
24 | * Return strong reference. | |
25 | */ | |
26 | QDict *qdict_new(void) | |
27 | { | |
28 | QDict *qdict; | |
29 | ||
7267c094 | 30 | qdict = g_malloc0(sizeof(*qdict)); |
55e1819c | 31 | qobject_init(QOBJECT(qdict), QTYPE_QDICT); |
fb08dde0 LC |
32 | |
33 | return qdict; | |
34 | } | |
35 | ||
fb08dde0 | 36 | /** |
e3a6e0da | 37 | * tdb_hash(): based on the hash algorithm from gdbm, via tdb |
fb08dde0 LC |
38 | * (from module-init-tools) |
39 | */ | |
40 | static unsigned int tdb_hash(const char *name) | |
41 | { | |
be08fb18 ZH |
42 | unsigned value; /* Used to compute the hash value. */ |
43 | unsigned i; /* Used to cycle through random values. */ | |
fb08dde0 LC |
44 | |
45 | /* Set the initial value from the key size. */ | |
1841f011 | 46 | for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) { |
f3d71c6e | 47 | value = (value + (((const unsigned char *)name)[i] << (i * 5 % 24))); |
1841f011 | 48 | } |
fb08dde0 LC |
49 | |
50 | return (1103515243 * value + 12345); | |
51 | } | |
52 | ||
53 | /** | |
54 | * alloc_entry(): allocate a new QDictEntry | |
55 | */ | |
56 | static QDictEntry *alloc_entry(const char *key, QObject *value) | |
57 | { | |
58 | QDictEntry *entry; | |
59 | ||
7267c094 AL |
60 | entry = g_malloc0(sizeof(*entry)); |
61 | entry->key = g_strdup(key); | |
fb08dde0 LC |
62 | entry->value = value; |
63 | ||
64 | return entry; | |
65 | } | |
66 | ||
0d078b2a LC |
67 | /** |
68 | * qdict_entry_value(): Return qdict entry value | |
69 | * | |
70 | * Return weak reference. | |
71 | */ | |
72 | QObject *qdict_entry_value(const QDictEntry *entry) | |
73 | { | |
74 | return entry->value; | |
75 | } | |
76 | ||
77 | /** | |
78 | * qdict_entry_key(): Return qdict entry key | |
79 | * | |
80 | * Return a *pointer* to the string, it has to be duplicated before being | |
81 | * stored. | |
82 | */ | |
83 | const char *qdict_entry_key(const QDictEntry *entry) | |
84 | { | |
85 | return entry->key; | |
86 | } | |
87 | ||
fb08dde0 LC |
88 | /** |
89 | * qdict_find(): List lookup function | |
90 | */ | |
91 | static QDictEntry *qdict_find(const QDict *qdict, | |
c8bc3cd7 | 92 | const char *key, unsigned int bucket) |
fb08dde0 LC |
93 | { |
94 | QDictEntry *entry; | |
95 | ||
c8bc3cd7 | 96 | QLIST_FOREACH(entry, &qdict->table[bucket], next) |
1841f011 | 97 | if (!strcmp(entry->key, key)) { |
fb08dde0 | 98 | return entry; |
1841f011 | 99 | } |
fb08dde0 LC |
100 | |
101 | return NULL; | |
102 | } | |
103 | ||
104 | /** | |
105 | * qdict_put_obj(): Put a new QObject into the dictionary | |
106 | * | |
107 | * Insert the pair 'key:value' into 'qdict', if 'key' already exists | |
108 | * its 'value' will be replaced. | |
109 | * | |
110 | * This is done by freeing the reference to the stored QObject and | |
111 | * storing the new one in the same entry. | |
112 | * | |
113 | * NOTE: ownership of 'value' is transferred to the QDict | |
114 | */ | |
115 | void qdict_put_obj(QDict *qdict, const char *key, QObject *value) | |
116 | { | |
c8bc3cd7 | 117 | unsigned int bucket; |
fb08dde0 LC |
118 | QDictEntry *entry; |
119 | ||
c8bc3cd7 LC |
120 | bucket = tdb_hash(key) % QDICT_BUCKET_MAX; |
121 | entry = qdict_find(qdict, key, bucket); | |
fb08dde0 LC |
122 | if (entry) { |
123 | /* replace key's value */ | |
cb3e7f08 | 124 | qobject_unref(entry->value); |
fb08dde0 LC |
125 | entry->value = value; |
126 | } else { | |
127 | /* allocate a new entry */ | |
128 | entry = alloc_entry(key, value); | |
c8bc3cd7 | 129 | QLIST_INSERT_HEAD(&qdict->table[bucket], entry, next); |
29ec3156 | 130 | qdict->size++; |
fb08dde0 | 131 | } |
fb08dde0 LC |
132 | } |
133 | ||
15280c36 MA |
134 | void qdict_put_int(QDict *qdict, const char *key, int64_t value) |
135 | { | |
136 | qdict_put(qdict, key, qnum_from_int(value)); | |
137 | } | |
138 | ||
139 | void qdict_put_bool(QDict *qdict, const char *key, bool value) | |
140 | { | |
141 | qdict_put(qdict, key, qbool_from_bool(value)); | |
142 | } | |
143 | ||
144 | void qdict_put_str(QDict *qdict, const char *key, const char *value) | |
145 | { | |
146 | qdict_put(qdict, key, qstring_from_str(value)); | |
147 | } | |
148 | ||
149 | void qdict_put_null(QDict *qdict, const char *key) | |
150 | { | |
151 | qdict_put(qdict, key, qnull()); | |
152 | } | |
153 | ||
fb08dde0 LC |
154 | /** |
155 | * qdict_get(): Lookup for a given 'key' | |
156 | * | |
157 | * Return a weak reference to the QObject associated with 'key' if | |
158 | * 'key' is present in the dictionary, NULL otherwise. | |
159 | */ | |
160 | QObject *qdict_get(const QDict *qdict, const char *key) | |
161 | { | |
162 | QDictEntry *entry; | |
163 | ||
c8bc3cd7 | 164 | entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX); |
fb08dde0 LC |
165 | return (entry == NULL ? NULL : entry->value); |
166 | } | |
167 | ||
168 | /** | |
169 | * qdict_haskey(): Check if 'key' exists | |
170 | * | |
171 | * Return 1 if 'key' exists in the dict, 0 otherwise | |
172 | */ | |
173 | int qdict_haskey(const QDict *qdict, const char *key) | |
174 | { | |
c8bc3cd7 LC |
175 | unsigned int bucket = tdb_hash(key) % QDICT_BUCKET_MAX; |
176 | return (qdict_find(qdict, key, bucket) == NULL ? 0 : 1); | |
fb08dde0 LC |
177 | } |
178 | ||
179 | /** | |
180 | * qdict_size(): Return the size of the dictionary | |
181 | */ | |
182 | size_t qdict_size(const QDict *qdict) | |
183 | { | |
184 | return qdict->size; | |
185 | } | |
186 | ||
acc3b033 MA |
187 | /** |
188 | * qdict_get_double(): Get an number mapped by 'key' | |
189 | * | |
01b2ffce | 190 | * This function assumes that 'key' exists and it stores a QNum. |
acc3b033 MA |
191 | * |
192 | * Return number mapped by 'key'. | |
193 | */ | |
194 | double qdict_get_double(const QDict *qdict, const char *key) | |
195 | { | |
7dc847eb | 196 | return qnum_get_double(qobject_to(QNum, qdict_get(qdict, key))); |
acc3b033 MA |
197 | } |
198 | ||
fb08dde0 LC |
199 | /** |
200 | * qdict_get_int(): Get an integer mapped by 'key' | |
201 | * | |
202 | * This function assumes that 'key' exists and it stores a | |
01b2ffce | 203 | * QNum representable as int. |
fb08dde0 LC |
204 | * |
205 | * Return integer mapped by 'key'. | |
206 | */ | |
207 | int64_t qdict_get_int(const QDict *qdict, const char *key) | |
208 | { | |
7dc847eb | 209 | return qnum_get_int(qobject_to(QNum, qdict_get(qdict, key))); |
fb08dde0 LC |
210 | } |
211 | ||
cd4dde36 LC |
212 | /** |
213 | * qdict_get_bool(): Get a bool mapped by 'key' | |
214 | * | |
215 | * This function assumes that 'key' exists and it stores a | |
216 | * QBool object. | |
217 | * | |
218 | * Return bool mapped by 'key'. | |
219 | */ | |
34acbc95 | 220 | bool qdict_get_bool(const QDict *qdict, const char *key) |
cd4dde36 | 221 | { |
7dc847eb | 222 | return qbool_get_bool(qobject_to(QBool, qdict_get(qdict, key))); |
cd4dde36 LC |
223 | } |
224 | ||
f2e17508 | 225 | /** |
b25f23e7 | 226 | * qdict_get_qlist(): If @qdict maps @key to a QList, return it, else NULL. |
f2e17508 LC |
227 | */ |
228 | QList *qdict_get_qlist(const QDict *qdict, const char *key) | |
229 | { | |
7dc847eb | 230 | return qobject_to(QList, qdict_get(qdict, key)); |
f2e17508 LC |
231 | } |
232 | ||
df10ce6a | 233 | /** |
b25f23e7 | 234 | * qdict_get_qdict(): If @qdict maps @key to a QDict, return it, else NULL. |
df10ce6a LC |
235 | */ |
236 | QDict *qdict_get_qdict(const QDict *qdict, const char *key) | |
237 | { | |
7dc847eb | 238 | return qobject_to(QDict, qdict_get(qdict, key)); |
df10ce6a LC |
239 | } |
240 | ||
fb08dde0 LC |
241 | /** |
242 | * qdict_get_str(): Get a pointer to the stored string mapped | |
243 | * by 'key' | |
244 | * | |
245 | * This function assumes that 'key' exists and it stores a | |
246 | * QString object. | |
247 | * | |
248 | * Return pointer to the string mapped by 'key'. | |
249 | */ | |
250 | const char *qdict_get_str(const QDict *qdict, const char *key) | |
251 | { | |
7dc847eb | 252 | return qstring_get_str(qobject_to(QString, qdict_get(qdict, key))); |
fb08dde0 LC |
253 | } |
254 | ||
255 | /** | |
256 | * qdict_get_try_int(): Try to get integer mapped by 'key' | |
257 | * | |
01b2ffce MAL |
258 | * Return integer mapped by 'key', if it is not present in the |
259 | * dictionary or if the stored object is not a QNum representing an | |
260 | * integer, 'def_value' will be returned. | |
fb08dde0 LC |
261 | */ |
262 | int64_t qdict_get_try_int(const QDict *qdict, const char *key, | |
83aba69e | 263 | int64_t def_value) |
fb08dde0 | 264 | { |
7dc847eb | 265 | QNum *qnum = qobject_to(QNum, qdict_get(qdict, key)); |
01b2ffce MAL |
266 | int64_t val; |
267 | ||
268 | if (!qnum || !qnum_get_try_int(qnum, &val)) { | |
269 | return def_value; | |
270 | } | |
fb08dde0 | 271 | |
01b2ffce | 272 | return val; |
fb08dde0 LC |
273 | } |
274 | ||
35006ac8 LC |
275 | /** |
276 | * qdict_get_try_bool(): Try to get a bool mapped by 'key' | |
277 | * | |
278 | * Return bool mapped by 'key', if it is not present in the | |
279 | * dictionary or if the stored object is not of QBool type | |
280 | * 'def_value' will be returned. | |
281 | */ | |
34acbc95 | 282 | bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value) |
35006ac8 | 283 | { |
7dc847eb | 284 | QBool *qbool = qobject_to(QBool, qdict_get(qdict, key)); |
35006ac8 | 285 | |
14b61600 | 286 | return qbool ? qbool_get_bool(qbool) : def_value; |
35006ac8 LC |
287 | } |
288 | ||
fb08dde0 LC |
289 | /** |
290 | * qdict_get_try_str(): Try to get a pointer to the stored string | |
291 | * mapped by 'key' | |
292 | * | |
293 | * Return a pointer to the string mapped by 'key', if it is not present | |
294 | * in the dictionary or if the stored object is not of QString type | |
295 | * NULL will be returned. | |
296 | */ | |
297 | const char *qdict_get_try_str(const QDict *qdict, const char *key) | |
298 | { | |
7dc847eb | 299 | QString *qstr = qobject_to(QString, qdict_get(qdict, key)); |
fb08dde0 | 300 | |
7f027843 | 301 | return qstr ? qstring_get_str(qstr) : NULL; |
fb08dde0 LC |
302 | } |
303 | ||
f2b07f35 LC |
304 | static QDictEntry *qdict_next_entry(const QDict *qdict, int first_bucket) |
305 | { | |
306 | int i; | |
307 | ||
308 | for (i = first_bucket; i < QDICT_BUCKET_MAX; i++) { | |
309 | if (!QLIST_EMPTY(&qdict->table[i])) { | |
310 | return QLIST_FIRST(&qdict->table[i]); | |
311 | } | |
312 | } | |
313 | ||
314 | return NULL; | |
315 | } | |
316 | ||
317 | /** | |
318 | * qdict_first(): Return first qdict entry for iteration. | |
319 | */ | |
320 | const QDictEntry *qdict_first(const QDict *qdict) | |
321 | { | |
322 | return qdict_next_entry(qdict, 0); | |
323 | } | |
324 | ||
325 | /** | |
326 | * qdict_next(): Return next qdict entry in an iteration. | |
327 | */ | |
328 | const QDictEntry *qdict_next(const QDict *qdict, const QDictEntry *entry) | |
329 | { | |
330 | QDictEntry *ret; | |
331 | ||
332 | ret = QLIST_NEXT(entry, next); | |
333 | if (!ret) { | |
334 | unsigned int bucket = tdb_hash(entry->key) % QDICT_BUCKET_MAX; | |
335 | ret = qdict_next_entry(qdict, bucket + 1); | |
336 | } | |
337 | ||
338 | return ret; | |
339 | } | |
340 | ||
b382bc9a KW |
341 | /** |
342 | * qdict_clone_shallow(): Clones a given QDict. Its entries are not copied, but | |
343 | * another reference is added. | |
344 | */ | |
345 | QDict *qdict_clone_shallow(const QDict *src) | |
346 | { | |
347 | QDict *dest; | |
348 | QDictEntry *entry; | |
349 | int i; | |
350 | ||
351 | dest = qdict_new(); | |
352 | ||
353 | for (i = 0; i < QDICT_BUCKET_MAX; i++) { | |
354 | QLIST_FOREACH(entry, &src->table[i], next) { | |
f5a74a5a | 355 | qdict_put_obj(dest, entry->key, qobject_ref(entry->value)); |
b382bc9a KW |
356 | } |
357 | } | |
358 | ||
359 | return dest; | |
360 | } | |
361 | ||
fb08dde0 LC |
362 | /** |
363 | * qentry_destroy(): Free all the memory allocated by a QDictEntry | |
364 | */ | |
365 | static void qentry_destroy(QDictEntry *e) | |
366 | { | |
367 | assert(e != NULL); | |
368 | assert(e->key != NULL); | |
369 | assert(e->value != NULL); | |
370 | ||
cb3e7f08 | 371 | qobject_unref(e->value); |
7267c094 AL |
372 | g_free(e->key); |
373 | g_free(e); | |
fb08dde0 LC |
374 | } |
375 | ||
376 | /** | |
377 | * qdict_del(): Delete a 'key:value' pair from the dictionary | |
378 | * | |
379 | * This will destroy all data allocated by this entry. | |
380 | */ | |
381 | void qdict_del(QDict *qdict, const char *key) | |
382 | { | |
383 | QDictEntry *entry; | |
384 | ||
c8bc3cd7 | 385 | entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX); |
fb08dde0 | 386 | if (entry) { |
72cf2d4f | 387 | QLIST_REMOVE(entry, next); |
fb08dde0 LC |
388 | qentry_destroy(entry); |
389 | qdict->size--; | |
390 | } | |
391 | } | |
392 | ||
b38dd678 HR |
393 | /** |
394 | * qdict_is_equal(): Test whether the two QDicts are equal | |
395 | * | |
396 | * Here, equality means whether they contain the same keys and whether | |
397 | * the respective values are in turn equal (i.e. invoking | |
398 | * qobject_is_equal() on them yields true). | |
399 | */ | |
400 | bool qdict_is_equal(const QObject *x, const QObject *y) | |
401 | { | |
7dc847eb HR |
402 | const QDict *dict_x = qobject_to(QDict, x); |
403 | const QDict *dict_y = qobject_to(QDict, y); | |
b38dd678 HR |
404 | const QDictEntry *e; |
405 | ||
406 | if (qdict_size(dict_x) != qdict_size(dict_y)) { | |
407 | return false; | |
408 | } | |
409 | ||
410 | for (e = qdict_first(dict_x); e; e = qdict_next(dict_x, e)) { | |
411 | const QObject *obj_x = qdict_entry_value(e); | |
412 | const QObject *obj_y = qdict_get(dict_y, qdict_entry_key(e)); | |
413 | ||
414 | if (!qobject_is_equal(obj_x, obj_y)) { | |
415 | return false; | |
416 | } | |
417 | } | |
418 | ||
419 | return true; | |
420 | } | |
421 | ||
fb08dde0 LC |
422 | /** |
423 | * qdict_destroy_obj(): Free all the memory allocated by a QDict | |
424 | */ | |
55e1819c | 425 | void qdict_destroy_obj(QObject *obj) |
fb08dde0 LC |
426 | { |
427 | int i; | |
428 | QDict *qdict; | |
429 | ||
430 | assert(obj != NULL); | |
7dc847eb | 431 | qdict = qobject_to(QDict, obj); |
fb08dde0 | 432 | |
c8bc3cd7 | 433 | for (i = 0; i < QDICT_BUCKET_MAX; i++) { |
72cf2d4f | 434 | QDictEntry *entry = QLIST_FIRST(&qdict->table[i]); |
fb08dde0 | 435 | while (entry) { |
72cf2d4f BS |
436 | QDictEntry *tmp = QLIST_NEXT(entry, next); |
437 | QLIST_REMOVE(entry, next); | |
fb08dde0 LC |
438 | qentry_destroy(entry); |
439 | entry = tmp; | |
440 | } | |
441 | } | |
442 | ||
7267c094 | 443 | g_free(qdict); |
fb08dde0 | 444 | } |
d709bbf3 MAL |
445 | |
446 | void qdict_unref(QDict *q) | |
447 | { | |
448 | qobject_unref(q); | |
449 | } |