From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:54951) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bO4gy-00079X-IP for qemu-devel@nongnu.org; Fri, 15 Jul 2016 11:06:18 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bO4gv-00071L-4n for qemu-devel@nongnu.org; Fri, 15 Jul 2016 11:06:16 -0400 Received: from mx1.redhat.com ([209.132.183.28]:54805) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bO4gu-00071E-TK for qemu-devel@nongnu.org; Fri, 15 Jul 2016 11:06:13 -0400 From: Markus Armbruster References: <1468505019-18154-1-git-send-email-berrange@redhat.com> <1468505019-18154-2-git-send-email-berrange@redhat.com> Date: Fri, 15 Jul 2016 17:06:08 +0200 In-Reply-To: <1468505019-18154-2-git-send-email-berrange@redhat.com> (Daniel P. Berrange's message of "Thu, 14 Jul 2016 15:03:33 +0100") Message-ID: <87shvbc55r.fsf@dusky.pond.sub.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Subject: Re: [Qemu-devel] [PATCH v8 1/7] qdict: implement a qdict_crumple method for un-flattening a dict List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: "Daniel P. Berrange" Cc: qemu-devel@nongnu.org, Max Reitz , =?utf-8?Q?Marc?= =?utf-8?Q?-Andr=C3=A9?= Lureau , Paolo Bonzini , Andreas =?utf-8?Q?F=C3=A4rber?= "Daniel P. Berrange" writes: > The qdict_flatten() method will take a dict whose elements are > further nested dicts/lists and flatten them by concatenating > keys. > > The qdict_crumple() method aims to do the reverse, taking a flat > qdict, and turning it into a set of nested dicts/lists. It will > apply nesting based on the key name, with a '.' indicating a > new level in the hierarchy. If the keys in the nested structure > are all numeric, it will create a list, otherwise it will create > a dict. > > If the keys are a mixture of numeric and non-numeric, or the > numeric keys are not in strictly ascending order, an error will > be reported. > > As an example, a flat dict containing > > { > 'foo.0.bar': 'one', > 'foo.0.wizz': '1', > 'foo.1.bar': 'two', > 'foo.1.wizz': '2' > } > > will get turned into a dict with one element 'foo' whose > value is a list. The list elements will each in turn be > dicts. > > { > 'foo': [ > { 'bar': 'one', 'wizz': '1' }, > { 'bar': 'two', 'wizz': '2' } > ], > } > > If the key is intended to contain a literal '.', then it must > be escaped as '..'. ie a flat dict > > { > 'foo..bar': 'wizz', > 'bar.foo..bar': 'eek', > 'bar.hello': 'world' > } > > Will end up as > > { > 'foo.bar': 'wizz', > 'bar': { > 'foo.bar': 'eek', > 'hello': 'world' > } > } > > The intent of this function is that it allows a set of QemuOpts > to be turned into a nested data structure that mirrors the nesting > used when the same object is defined over QMP. > > Reviewed-by: Marc-Andr=C3=A9 Lureau > Signed-off-by: Daniel P. Berrange > --- > include/qapi/qmp/qdict.h | 1 + > qobject/qdict.c | 283 +++++++++++++++++++++++++++++++++++++++++= ++++++ > tests/check-qdict.c | 241 ++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 525 insertions(+) > > diff --git a/include/qapi/qmp/qdict.h b/include/qapi/qmp/qdict.h > index 71b8eb0..8a3ac13 100644 > --- a/include/qapi/qmp/qdict.h > +++ b/include/qapi/qmp/qdict.h > @@ -73,6 +73,7 @@ void qdict_flatten(QDict *qdict); > void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start); > void qdict_array_split(QDict *src, QList **dst); > int qdict_array_entries(QDict *src, const char *subqdict); > +QObject *qdict_crumple(QDict *src, bool recursive, Error **errp); >=20=20 > void qdict_join(QDict *dest, QDict *src, bool overwrite); >=20=20 > diff --git a/qobject/qdict.c b/qobject/qdict.c > index 60f158c..fd2d0e3 100644 > --- a/qobject/qdict.c > +++ b/qobject/qdict.c > @@ -17,6 +17,7 @@ > #include "qapi/qmp/qbool.h" > #include "qapi/qmp/qstring.h" > #include "qapi/qmp/qobject.h" > +#include "qapi/error.h" > #include "qemu/queue.h" > #include "qemu-common.h" > #include "qemu/cutils.h" > @@ -683,6 +684,288 @@ void qdict_array_split(QDict *src, QList **dst) > } > } >=20=20 > + > +/** > + * qdict_split_flat_key: > + * @key: the key string to split > + * @prefix: non-NULL pointer to hold extracted prefix > + * @suffix: non-NULL pointer to remaining suffix > + * > + * Given a flattened key such as 'foo.0.bar', split it into two parts > + * at the first '.' separator. Allows double dot ('..') to escape the > + * normal separator. > + * > + * eg > + * 'foo.0.bar' -> prefix=3D'foo' and suffix=3D'0.bar' > + * 'foo..0.bar' -> prefix=3D'foo.0' and suffix=3D'bar' > + * > + * The '..' sequence will be unescaped in the returned 'prefix' > + * string. The 'suffix' string will be left in escaped format, so it > + * can be fed back into the qdict_split_flat_key() key as the input > + * later. > + * > + * The caller is responsible for freeing the string returned in @prefix > + * using g_free(). > + */ > +static void qdict_split_flat_key(const char *key, char **prefix, > + const char **suffix) > +{ > + const char *separator; > + size_t i, j; > + > + /* Find first '.' separator, but if there is a pair '..' > + * that acts as an escape, so skip over '..' */ > + separator =3D NULL; > + do { > + if (separator) { > + separator +=3D 2; > + } else { > + separator =3D key; > + } > + separator =3D strchr(separator, '.'); > + } while (separator && separator[1] =3D=3D '.'); > + > + if (separator) { > + *prefix =3D g_strndup(key, > + separator - key); > + *suffix =3D separator + 1; > + } else { > + *prefix =3D g_strdup(key); > + *suffix =3D NULL; > + } > + > + /* Unescape the '..' sequence into '.' */ > + for (i =3D 0, j =3D 0; (*prefix)[i] !=3D '\0'; i++, j++) { > + if ((*prefix)[i] =3D=3D '.') { > + assert((*prefix)[i + 1] =3D=3D '.'); > + i++; > + } > + (*prefix)[j] =3D (*prefix)[i]; > + } > + (*prefix)[j] =3D '\0'; > +} > + > + > +/** > + * qdict_is_list: > + * @maybe_list: dict to check if keys represent list elements. > + * > + * Determine whether all keys in @maybe_list are valid list elements. > + * If @maybe_list is non-zero in length and all the keys look like > + * valid list indexes, this will return 1. If @maybe_list is zero > + * length or all keys are non-numeric then it will return 0 to indicate > + * it is a normal qdict. If there is a mix of numeric and non-numeric > + * keys, or the list indexes are non-contiguous, an error is reported. > + * > + * Returns: 1 if a valid list, 0 if a dict, -1 on error > + */ > +static int qdict_is_list(QDict *maybe_list, Error **errp) > +{ > + const QDictEntry *ent; > + ssize_t len =3D 0; > + ssize_t max =3D -1; > + int is_list =3D -1; > + int64_t val; > + > + for (ent =3D qdict_first(maybe_list); ent !=3D NULL; > + ent =3D qdict_next(maybe_list, ent)) { > + > + if (qemu_strtoll(ent->key, NULL, 10, &val) =3D=3D 0) { > + if (is_list =3D=3D -1) { > + is_list =3D 1; > + } else if (!is_list) { > + error_setg(errp, > + "Cannot crumple a dictionary with a mix of li= st " > + "and non-list keys"); > + return -1; > + } > + len++; > + if (val > max) { > + max =3D val; > + } > + } else { > + if (is_list =3D=3D -1) { > + is_list =3D 0; > + } else if (is_list) { > + error_setg(errp, > + "Cannot crumple a dictionary with a mix of li= st " > + "and non-list keys"); > + return -1; > + } > + } > + } > + > + if (is_list =3D=3D -1) { > + assert(!qdict_size(maybe_list)); > + is_list =3D 0; > + } > + > + if (len !=3D (max + 1)) { > + error_setg(errp, "List indexes are not contigous, " contiguous > + "saw %zd elements but %zd largest index", > + len, max); > + return -1; > + } > + > + return is_list ? 1 : 0; Why not simply return is_list? > +} [...]