blob: 8faff230d39152fb42894266a8d49fa5a612ac3c [file] [log] [blame]
Luiz Capitulinofb08dde2009-08-28 15:27:07 -03001/*
Luiz Capitulino41836a92010-05-12 16:34:42 -03002 * QDict Module
Luiz Capitulinofb08dde2009-08-28 15:27:07 -03003 *
4 * Copyright (C) 2009 Red Hat Inc.
5 *
6 * Authors:
7 * Luiz Capitulino <lcapitulino@redhat.com>
8 *
Luiz Capitulino41836a92010-05-12 16:34:42 -03009 * 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.
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030011 */
12
Peter Maydellf2ad72b2016-01-29 17:50:01 +000013#include "qemu/osdep.h"
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +040014#include "qapi/qmp/qnum.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010015#include "qapi/qmp/qdict.h"
16#include "qapi/qmp/qbool.h"
Markus Armbruster15280c32018-02-01 12:18:36 +010017#include "qapi/qmp/qnull.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010018#include "qapi/qmp/qstring.h"
Markus Armbruster80d71122020-12-11 18:11:40 +010019#include "qobject-internal.h"
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030020
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030021/**
22 * qdict_new(): Create a new QDict
23 *
24 * Return strong reference.
25 */
26QDict *qdict_new(void)
27{
28 QDict *qdict;
29
Anthony Liguori7267c092011-08-20 22:09:37 -050030 qdict = g_malloc0(sizeof(*qdict));
Eric Blake55e18192015-12-01 22:20:45 -070031 qobject_init(QOBJECT(qdict), QTYPE_QDICT);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030032
33 return qdict;
34}
35
36/**
zhaolichange3a6e0d2020-09-17 15:50:20 +080037 * tdb_hash(): based on the hash algorithm from gdbm, via tdb
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030038 * (from module-init-tools)
39 */
40static unsigned int tdb_hash(const char *name)
41{
Zhang Hanbe08fb12020-12-28 15:11:27 +080042 unsigned value; /* Used to compute the hash value. */
43 unsigned i; /* Used to cycle through random values. */
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030044
45 /* Set the initial value from the key size. */
Zhang Han1841f012020-12-28 15:11:29 +080046 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) {
Zhang Hanf3d71c62020-12-28 15:11:28 +080047 value = (value + (((const unsigned char *)name)[i] << (i * 5 % 24)));
Zhang Han1841f012020-12-28 15:11:29 +080048 }
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030049
50 return (1103515243 * value + 12345);
51}
52
53/**
54 * alloc_entry(): allocate a new QDictEntry
55 */
56static QDictEntry *alloc_entry(const char *key, QObject *value)
57{
58 QDictEntry *entry;
59
Anthony Liguori7267c092011-08-20 22:09:37 -050060 entry = g_malloc0(sizeof(*entry));
61 entry->key = g_strdup(key);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030062 entry->value = value;
63
64 return entry;
65}
66
67/**
Luiz Capitulino0d078b22010-06-07 16:53:51 -030068 * qdict_entry_value(): Return qdict entry value
69 *
70 * Return weak reference.
71 */
72QObject *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 */
83const char *qdict_entry_key(const QDictEntry *entry)
84{
85 return entry->key;
86}
87
88/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030089 * qdict_find(): List lookup function
90 */
91static QDictEntry *qdict_find(const QDict *qdict,
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -030092 const char *key, unsigned int bucket)
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030093{
94 QDictEntry *entry;
95
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -030096 QLIST_FOREACH(entry, &qdict->table[bucket], next)
Zhang Han1841f012020-12-28 15:11:29 +080097 if (!strcmp(entry->key, key)) {
Luiz Capitulinofb08dde2009-08-28 15:27:07 -030098 return entry;
Zhang Han1841f012020-12-28 15:11:29 +080099 }
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300100
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 */
115void qdict_put_obj(QDict *qdict, const char *key, QObject *value)
116{
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300117 unsigned int bucket;
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300118 QDictEntry *entry;
119
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300120 bucket = tdb_hash(key) % QDICT_BUCKET_MAX;
121 entry = qdict_find(qdict, key, bucket);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300122 if (entry) {
123 /* replace key's value */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200124 qobject_unref(entry->value);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300125 entry->value = value;
126 } else {
127 /* allocate a new entry */
128 entry = alloc_entry(key, value);
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300129 QLIST_INSERT_HEAD(&qdict->table[bucket], entry, next);
Luiz Capitulino29ec3152009-12-14 18:53:20 -0200130 qdict->size++;
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300131 }
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300132}
133
Markus Armbruster15280c32018-02-01 12:18:36 +0100134void qdict_put_int(QDict *qdict, const char *key, int64_t value)
135{
136 qdict_put(qdict, key, qnum_from_int(value));
137}
138
139void qdict_put_bool(QDict *qdict, const char *key, bool value)
140{
141 qdict_put(qdict, key, qbool_from_bool(value));
142}
143
144void qdict_put_str(QDict *qdict, const char *key, const char *value)
145{
146 qdict_put(qdict, key, qstring_from_str(value));
147}
148
149void qdict_put_null(QDict *qdict, const char *key)
150{
151 qdict_put(qdict, key, qnull());
152}
153
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300154/**
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 */
160QObject *qdict_get(const QDict *qdict, const char *key)
161{
162 QDictEntry *entry;
163
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300164 entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300165 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 */
173int qdict_haskey(const QDict *qdict, const char *key)
174{
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300175 unsigned int bucket = tdb_hash(key) % QDICT_BUCKET_MAX;
176 return (qdict_find(qdict, key, bucket) == NULL ? 0 : 1);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300177}
178
179/**
180 * qdict_size(): Return the size of the dictionary
181 */
182size_t qdict_size(const QDict *qdict)
183{
184 return qdict->size;
185}
186
187/**
Markus Armbrusteracc3b032010-01-27 17:16:38 +0100188 * qdict_get_double(): Get an number mapped by 'key'
189 *
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400190 * This function assumes that 'key' exists and it stores a QNum.
Markus Armbrusteracc3b032010-01-27 17:16:38 +0100191 *
192 * Return number mapped by 'key'.
193 */
194double qdict_get_double(const QDict *qdict, const char *key)
195{
Max Reitz7dc847e2018-02-24 16:40:29 +0100196 return qnum_get_double(qobject_to(QNum, qdict_get(qdict, key)));
Markus Armbrusteracc3b032010-01-27 17:16:38 +0100197}
198
199/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300200 * qdict_get_int(): Get an integer mapped by 'key'
201 *
202 * This function assumes that 'key' exists and it stores a
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400203 * QNum representable as int.
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300204 *
205 * Return integer mapped by 'key'.
206 */
207int64_t qdict_get_int(const QDict *qdict, const char *key)
208{
Max Reitz7dc847e2018-02-24 16:40:29 +0100209 return qnum_get_int(qobject_to(QNum, qdict_get(qdict, key)));
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300210}
211
212/**
Luiz Capitulinocd4dde32009-12-10 17:15:53 -0200213 * 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 */
Eric Blake34acbc92015-05-15 16:25:00 -0600220bool qdict_get_bool(const QDict *qdict, const char *key)
Luiz Capitulinocd4dde32009-12-10 17:15:53 -0200221{
Max Reitz7dc847e2018-02-24 16:40:29 +0100222 return qbool_get_bool(qobject_to(QBool, qdict_get(qdict, key)));
Luiz Capitulinocd4dde32009-12-10 17:15:53 -0200223}
224
225/**
Markus Armbrusterb25f23e2017-02-17 21:38:12 +0100226 * qdict_get_qlist(): If @qdict maps @key to a QList, return it, else NULL.
Luiz Capitulinof2e17502009-12-10 17:15:54 -0200227 */
228QList *qdict_get_qlist(const QDict *qdict, const char *key)
229{
Max Reitz7dc847e2018-02-24 16:40:29 +0100230 return qobject_to(QList, qdict_get(qdict, key));
Luiz Capitulinof2e17502009-12-10 17:15:54 -0200231}
232
233/**
Markus Armbrusterb25f23e2017-02-17 21:38:12 +0100234 * qdict_get_qdict(): If @qdict maps @key to a QDict, return it, else NULL.
Luiz Capitulinodf10ce62010-01-21 19:15:39 -0200235 */
236QDict *qdict_get_qdict(const QDict *qdict, const char *key)
237{
Max Reitz7dc847e2018-02-24 16:40:29 +0100238 return qobject_to(QDict, qdict_get(qdict, key));
Luiz Capitulinodf10ce62010-01-21 19:15:39 -0200239}
240
241/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300242 * 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 */
250const char *qdict_get_str(const QDict *qdict, const char *key)
251{
Max Reitz7dc847e2018-02-24 16:40:29 +0100252 return qstring_get_str(qobject_to(QString, qdict_get(qdict, key)));
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300253}
254
255/**
256 * qdict_get_try_int(): Try to get integer mapped by 'key'
257 *
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400258 * 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.
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300261 */
262int64_t qdict_get_try_int(const QDict *qdict, const char *key,
Luiz Capitulino83aba692010-06-04 19:20:54 -0300263 int64_t def_value)
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300264{
Max Reitz7dc847e2018-02-24 16:40:29 +0100265 QNum *qnum = qobject_to(QNum, qdict_get(qdict, key));
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400266 int64_t val;
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300267
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400268 if (!qnum || !qnum_get_try_int(qnum, &val)) {
269 return def_value;
270 }
271
272 return val;
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300273}
274
275/**
Luiz Capitulino35006ac2010-06-07 17:25:04 -0300276 * 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 */
Eric Blake34acbc92015-05-15 16:25:00 -0600282bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value)
Luiz Capitulino35006ac2010-06-07 17:25:04 -0300283{
Max Reitz7dc847e2018-02-24 16:40:29 +0100284 QBool *qbool = qobject_to(QBool, qdict_get(qdict, key));
Luiz Capitulino35006ac2010-06-07 17:25:04 -0300285
Markus Armbruster14b61602015-10-15 16:15:33 +0200286 return qbool ? qbool_get_bool(qbool) : def_value;
Luiz Capitulino35006ac2010-06-07 17:25:04 -0300287}
288
289/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300290 * 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 */
297const char *qdict_get_try_str(const QDict *qdict, const char *key)
298{
Max Reitz7dc847e2018-02-24 16:40:29 +0100299 QString *qstr = qobject_to(QString, qdict_get(qdict, key));
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300300
Markus Armbruster7f027842015-10-15 16:15:37 +0200301 return qstr ? qstring_get_str(qstr) : NULL;
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300302}
303
Luiz Capitulinof2b07f32010-06-07 16:07:29 -0300304static 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 */
320const 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 */
328const 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
Luiz Capitulino21f800d2009-10-13 13:56:58 -0300341/**
Kevin Wolfb382bc92013-03-15 10:35:03 +0100342 * qdict_clone_shallow(): Clones a given QDict. Its entries are not copied, but
343 * another reference is added.
344 */
345QDict *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) {
Marc-André Lureauf5a74a52018-04-19 17:01:44 +0200355 qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
Kevin Wolfb382bc92013-03-15 10:35:03 +0100356 }
357 }
358
359 return dest;
360}
361
362/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300363 * qentry_destroy(): Free all the memory allocated by a QDictEntry
364 */
365static void qentry_destroy(QDictEntry *e)
366{
367 assert(e != NULL);
368 assert(e->key != NULL);
369 assert(e->value != NULL);
370
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200371 qobject_unref(e->value);
Anthony Liguori7267c092011-08-20 22:09:37 -0500372 g_free(e->key);
373 g_free(e);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300374}
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 */
381void qdict_del(QDict *qdict, const char *key)
382{
383 QDictEntry *entry;
384
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300385 entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300386 if (entry) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000387 QLIST_REMOVE(entry, next);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300388 qentry_destroy(entry);
389 qdict->size--;
390 }
391}
392
393/**
Max Reitzb38dd672017-11-14 19:01:25 +0100394 * 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 */
400bool qdict_is_equal(const QObject *x, const QObject *y)
401{
Max Reitz7dc847e2018-02-24 16:40:29 +0100402 const QDict *dict_x = qobject_to(QDict, x);
403 const QDict *dict_y = qobject_to(QDict, y);
Max Reitzb38dd672017-11-14 19:01:25 +0100404 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
422/**
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300423 * qdict_destroy_obj(): Free all the memory allocated by a QDict
424 */
Eric Blake55e18192015-12-01 22:20:45 -0700425void qdict_destroy_obj(QObject *obj)
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300426{
427 int i;
428 QDict *qdict;
429
430 assert(obj != NULL);
Max Reitz7dc847e2018-02-24 16:40:29 +0100431 qdict = qobject_to(QDict, obj);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300432
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -0300433 for (i = 0; i < QDICT_BUCKET_MAX; i++) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000434 QDictEntry *entry = QLIST_FIRST(&qdict->table[i]);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300435 while (entry) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000436 QDictEntry *tmp = QLIST_NEXT(entry, next);
437 QLIST_REMOVE(entry, next);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300438 qentry_destroy(entry);
439 entry = tmp;
440 }
441 }
442
Anthony Liguori7267c092011-08-20 22:09:37 -0500443 g_free(qdict);
Luiz Capitulinofb08dde2009-08-28 15:27:07 -0300444}
Marc-André Lureaud709bbf2022-03-23 19:57:20 +0400445
446void qdict_unref(QDict *q)
447{
448 qobject_unref(q);
449}