diff options
| -rw-r--r-- | docs/reference/glib/glib-docs.sgml | 1 | ||||
| -rw-r--r-- | docs/reference/glib/glib-sections.txt | 68 | ||||
| -rw-r--r-- | glib/Makefile.am | 2 | ||||
| -rw-r--r-- | glib/glib.h | 1 | ||||
| -rw-r--r-- | glib/glib.symbols | 34 | ||||
| -rw-r--r-- | glib/gvarianttype.c | 1495 | ||||
| -rw-r--r-- | glib/gvarianttype.h | 282 |
7 files changed, 1883 insertions, 0 deletions
diff --git a/docs/reference/glib/glib-docs.sgml b/docs/reference/glib/glib-docs.sgml index 2bd1dcd51..23a7ce5c7 100644 --- a/docs/reference/glib/glib-docs.sgml +++ b/docs/reference/glib/glib-docs.sgml @@ -119,6 +119,7 @@ synchronize their operation. <xi:include href="xml/relations.xml" /> <xi:include href="xml/caches.xml" /> <xi:include href="xml/allocators.xml" /> + <xi:include href="xml/gvarianttype.xml"/> </chapter> <chapter id="tools"> diff --git a/docs/reference/glib/glib-sections.txt b/docs/reference/glib/glib-sections.txt index 99483da1f..4393fa92a 100644 --- a/docs/reference/glib/glib-sections.txt +++ b/docs/reference/glib/glib-sections.txt @@ -2701,6 +2701,74 @@ g_test_log_buffer_pop g_test_log_msg_free </SECTION> +<SECTION> +<TITLE>GVariantType</TITLE> +<FILE>gvarianttype</FILE> +GVariantType +G_VARIANT_TYPE_BOOLEAN +G_VARIANT_TYPE_BYTE +G_VARIANT_TYPE_INT16 +G_VARIANT_TYPE_UINT16 +G_VARIANT_TYPE_INT32 +G_VARIANT_TYPE_UINT32 +G_VARIANT_TYPE_INT64 +G_VARIANT_TYPE_UINT64 +G_VARIANT_TYPE_HANDLE +G_VARIANT_TYPE_DOUBLE +G_VARIANT_TYPE_STRING +G_VARIANT_TYPE_OBJECT_PATH +G_VARIANT_TYPE_SIGNATURE +G_VARIANT_TYPE_VARIANT +G_VARIANT_TYPE_ANY +G_VARIANT_TYPE_BASIC +G_VARIANT_TYPE_MAYBE +G_VARIANT_TYPE_ARRAY +G_VARIANT_TYPE_TUPLE +G_VARIANT_TYPE_UNIT +G_VARIANT_TYPE_DICT_ENTRY +G_VARIANT_TYPE_DICTIONARY + +<SUBSECTION> +G_VARIANT_TYPE +g_variant_type_free +g_variant_type_copy +g_variant_type_new + +<SUBSECTION> +g_variant_type_string_is_valid +g_variant_type_string_scan +g_variant_type_get_string_length +g_variant_type_peek_string +g_variant_type_dup_string + +<SUBSECTION> +g_variant_type_is_definite +g_variant_type_is_container +g_variant_type_is_basic +g_variant_type_is_maybe +g_variant_type_is_array +g_variant_type_is_tuple +g_variant_type_is_dict_entry + +<SUBSECTION> +g_variant_type_hash +g_variant_type_equal +g_variant_type_is_subtype_of + +<SUBSECTION> +g_variant_type_new_maybe +g_variant_type_new_array +g_variant_type_new_tuple +g_variant_type_new_dict_entry + +<SUBSECTION> +g_variant_type_element +g_variant_type_n_items +g_variant_type_first +g_variant_type_next +g_variant_type_key +g_variant_type_value +</SECTION> <SECTION> <FILE>ghostutils</FILE> diff --git a/glib/Makefile.am b/glib/Makefile.am index 57019223f..d285ffdef 100644 --- a/glib/Makefile.am +++ b/glib/Makefile.am @@ -171,6 +171,7 @@ libglib_2_0_la_SOURCES = \ gunicodeprivate.h \ gurifuncs.c \ gutils.c \ + gvarianttype.c \ gdebug.h \ gprintf.c \ gprintfint.h @@ -248,6 +249,7 @@ glibsubinclude_HEADERS = \ gunicode.h \ gurifuncs.h \ gutils.h \ + gvarianttype.h \ gwin32.h \ gprintf.h diff --git a/glib/glib.h b/glib/glib.h index f8acdd259..209971d49 100644 --- a/glib/glib.h +++ b/glib/glib.h @@ -85,6 +85,7 @@ #include <glib/gunicode.h> #include <glib/gurifuncs.h> #include <glib/gutils.h> +#include <glib/gvarianttype.h> #ifdef G_PLATFORM_WIN32 #include <glib/gwin32.h> #endif diff --git a/glib/glib.symbols b/glib/glib.symbols index 6e3a63b36..ad2b5090c 100644 --- a/glib/glib.symbols +++ b/glib/glib.symbols @@ -1644,6 +1644,40 @@ g_match_info_fetch_all #endif #endif +#if IN_HEADER(__G_VARIANT_TYPE_H__) +#if IN_FILE(__G_VARIANT_TYPE_C__) +g_variant_type_string_is_valid +g_variant_type_string_scan +g_variant_type_free +g_variant_type_copy +g_variant_type_new +g_variant_type_get_string_length +g_variant_type_peek_string +g_variant_type_dup_string +g_variant_type_is_definite +g_variant_type_is_container +g_variant_type_is_basic +g_variant_type_is_maybe +g_variant_type_is_array +g_variant_type_is_tuple +g_variant_type_is_dict_entry +g_variant_type_hash +g_variant_type_equal +g_variant_type_is_subtype_of +g_variant_type_element +g_variant_type_first +g_variant_type_next +g_variant_type_n_items +g_variant_type_key +g_variant_type_value +g_variant_type_new_array +g_variant_type_new_maybe +g_variant_type_new_tuple +g_variant_type_new_dict_entry +g_variant_type_checked_ +#endif +#endif + #if IN_HEADER(__G_WIN32_H__) #if IN_FILE(__G_WIN32_H__) #ifdef G_OS_WIN32 diff --git a/glib/gvarianttype.c b/glib/gvarianttype.c new file mode 100644 index 000000000..c70f8d78f --- /dev/null +++ b/glib/gvarianttype.c @@ -0,0 +1,1495 @@ +/* + * Copyright © 2007, 2008 Ryan Lortie + * Copyright © 2009, 2010 Codethink Limited + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the licence, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + * Author: Ryan Lortie <desrt@desrt.ca> + */ + +#include "gvarianttype.h" + +#include <glib/gtestutils.h> + +#include <string.h> + +#include "galias.h" + +/** + * SECTION: gvarianttype + * @title: GVariantType + * @short_description: introduction to the GVariant type system + * @see_also: #GVariantType, #GVariant + * + * This section introduces the GVariant type system. It is based, in + * large part, on the DBus type system, with two major changes and some minor + * lifting of restrictions. The <ulink + * url='http://dbus.freedesktop.org/doc/dbus-specification.html'>DBus + * specification</ulink>, therefore, provides a significant amount of + * information that is useful when working with GVariant. + * + * The first major change with respect to the DBus type system is the + * introduction of maybe (or "nullable") types. Any type in GVariant can be + * converted to a maybe type, in which case, "nothing" (or "null") becomes a + * valid value. Maybe types have been added by introducing the + * character "<literal>m</literal>" to type strings. + * + * The second major change is that the GVariant type system supports the + * concept of "indefinite types" -- types that are less specific than + * the normal types found in DBus. For example, it is possible to speak + * of "an array of any type" in GVariant, where the DBus type system + * would require you to speak of "an array of integers" or "an array of + * strings". Indefinite types have been added by introducing the + * characters "<literal>*</literal>", "<literal>?</literal>" and + * "<literal>r</literal>" to type strings. + * + * Finally, all arbitrary restrictions relating to the complexity of + * types are lifted along with the restriction that dictionary entries + * may only appear nested inside of arrays. + * + * Just as in DBus, GVariant types are described with strings ("type + * strings"). Subject to the differences mentioned above, these strings + * are of the same form as those found in DBus. Note, however: DBus + * always works in terms of messages and therefore individual type + * strings appear nowhere in its interface. Instead, "signatures" + * are a concatenation of the strings of the type of each argument in a + * message. GVariant deals with single values directly so GVariant type + * strings always describe the type of exactly one value. This means + * that a DBus signature string is generally not a valid GVariant type + * string -- except in the case that it is the signature of a message + * containing exactly one argument. + * + * An indefinite type is similar in spirit to what may be called an + * abstract type in other type systems. No value can exist that has an + * indefinite type as its type, but values can exist that have types + * that are subtypes of indefinite types. That is to say, + * g_variant_get_type() will never return an indefinite type, but + * calling g_variant_is_a() with an indefinite type may return %TRUE. + * For example, you can not have a value that represents "an array of no + * particular type", but you can have an "array of integers" which + * certainly matches the type of "an array of no particular type", since + * "array of integers" is a subtype of "array of no particular type". + * + * This is similar to how instances of abstract classes may not + * directly exist in other type systems, but instances of their + * non-abstract subtypes may. For example, in GTK, no object that has + * the type of #GtkBin can exist (since #GtkBin is an abstract class), + * but a #GtkWindow can certainly be instantiated, and you would say + * that the #GtkWindow is a #GtkBin (since #GtkWindow is a subclass of + * #GtkBin). + * + * A detailed description of GVariant type strings is given here: + * + * <refsect2 id='gvariant-typestrings'> + * <title>GVariant Type Strings</title> + * <para> + * A GVariant type string can be any of the following: + * </para> + * <itemizedlist> + * <listitem> + * <para> + * any basic type string (listed below) + * </para> + * </listitem> + * <listitem> + * <para> + * "<literal>v</literal>", "<literal>r</literal>" or + * "<literal>*</literal>" + * </para> + * </listitem> + * <listitem> + * <para> + * one of the characters '<literal>a</literal>' or + * '<literal>m</literal>', followed by another type string + * </para> + * </listitem> + * <listitem> + * <para> + * the character '<literal>(</literal>', followed by a concatenation + * of zero or more other type strings, followed by the character + * '<literal>)</literal>' + * </para> + * </listitem> + * <listitem> + * <para> + * the character '<literal>{</literal>', followed by a basic type + * string (see below), followed by another type string, followed by + * the character '<literal>}</literal>' + * </para> + * </listitem> + * </itemizedlist> + * <para> + * A basic type string describes a basic type (as per + * g_variant_type_is_basic()) and is always a single + * character in length. The valid basic type strings are + * "<literal>b</literal>", "<literal>y</literal>", + * "<literal>n</literal>", "<literal>q</literal>", + * "<literal>i</literal>", "<literal>u</literal>", + * "<literal>x</literal>", "<literal>t</literal>", + * "<literal>h</literal>", "<literal>d</literal>", + * "<literal>s</literal>", "<literal>o</literal>", + * "<literal>g</literal>" and "<literal>?</literal>". + * </para> + * <para> + * The above definition is recursive to arbitrary depth. + * "<literal>aaaaai</literal>" and "<literal>(ui(nq((y)))s)</literal>" + * are both valid type strings, as is + * "<literal>a(aa(ui)(qna{ya(yd)}))</literal>". + * </para> + * <para> + * The meaning of each of the characters is as follows: + * </para> + * <informaltable> + * <tgroup cols='2'> + * <tbody> + * <row> + * <entry> + * <para> + * <emphasis role='strong'>Character</emphasis> + * </para> + * </entry> + * <entry> + * <para> + * <emphasis role='strong'>Meaning</emphasis> + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>b</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_BOOLEAN; a boolean value. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>y</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_BYTE; a byte. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>n</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_INT16; a signed 16 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>q</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_UINT16; an unsigned 16 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>i</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_INT32; a signed 32 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>u</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_UINT32; an unsigned 32 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>x</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_INT64; a signed 64 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>t</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_UINT64; an unsigned 64 bit + * integer. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>h</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit + * value that, by convention, is used as an index into an array + * of file descriptors that are sent alongside a DBus message. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>d</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_DOUBLE; a double precision + * floating point value. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>s</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_STRING; a string. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>o</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_OBJECT_PATH; a string in + * the form of a DBus object path. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>g</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_STRING; a string in the + * form of a DBus type signature. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>?</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_BASIC; an indefinite type + * that is a supertype of any of the basic types. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>v</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_VARIANT; a container type + * that contain any other type of value. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>a</literal> + * </para> + * </entry> + * <entry> + * <para> + * used as a prefix on another type string to mean an array of + * that type; the type string "<literal>ai</literal>", for + * example, is the type of an array of 32 bit signed integers. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>m</literal> + * </para> + * </entry> + * <entry> + * <para> + * used as a prefix on another type string to mean a "maybe", or + * "nullable", version of that type; the type string + * "<literal>ms</literal>", for example, is the type of a value + * that maybe contains a string, or maybe contains nothing. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>()</literal> + * </para> + * </entry> + * <entry> + * <para> + * used to enclose zero or more other concatenated type strings + * to create a tuple type; the type string + * "<literal>(is)</literal>", for example, is the type of a pair + * of an integer and a string. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>r</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_TUPLE; an indefinite type + * that is a supertype of any tuple type, regardless of the + * number of items. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>{}</literal> + * </para> + * </entry> + * <entry> + * <para> + * used to enclose a basic type string concatenated with another + * type string to create a dictionary entry type, which usually + * appears inside of an array to form a dictionary; the type + * string "<literal>a{sd}</literal>", for example, is the type of + * a dictionary that maps strings to double precision floating + * point values. + * </para> + * <para> + * The first type (the basic type) is the key type and the second + * type is the value type. The reason that the first type is + * restricted to being a basic type is so that it can easily be + * hashed. + * </para> + * </entry> + * </row> + * <row> + * <entry> + * <para> + * <literal>*</literal> + * </para> + * </entry> + * <entry> + * <para> + * the type string of %G_VARIANT_TYPE_ANY; the indefinite type + * that is a supertype of all types. Note that, as with all type + * strings, this character represents exactly one type. It + * cannot be used inside of tuples to mean "any number of items". + * </para> + * </entry> + * </row> + * </tbody> + * </tgroup> + * </informaltable> + * <para> + * Any type string of a container that contains an indefinite type is, + * itself, an indefinite type. For example, the type string + * "<literal>a*</literal>" (corresponding to %G_VARIANT_TYPE_ARRAY) is + * an indefinite type that is a supertype of every array type. + * "<literal>(*s)</literal>" is a supertype of all tuples that + * contain exactly two items where the second item is a string. + * </para> + * <para> + * "<literal>a{?*}</literal>" is an indefinite type that is a + * supertype of all arrays containing dictionary entries where the key + * is any basic type and the value is any type at all. This is, by + * definition, a dictionary, so this type string corresponds to + * %G_VARIANT_TYPE_DICTIONARY. Note that, due to the restriction that + * the key of a dictionary entry must be a basic type, + * "<literal>{**}</literal>" is not a valid type string. + * </para> + * </refsect2> + */ + +/** + * GVariantType: + * + * A type in the GVariant type system. + * + * Two types may not be compared by value; use g_variant_type_equal() or + * g_variant_type_is_subtype(). May be copied using + * g_variant_type_copy() and freed using g_variant_type_free(). + **/ + +/** + * G_VARIANT_TYPE: + * @type_string: a well-formed #GVariantType type string + * + * Converts a string to a const #GVariantType. Depending on the + * current debugging level, this function may perform a runtime check + * to ensure that @string is a valid GVariant type string. + * + * It is always a programmer error to use this macro with an invalid + * type string. + * + * Since 2.24 + **/ + +static gboolean +g_variant_type_check (const GVariantType *type) +{ + const gchar *type_string; + + if (type == NULL) + return FALSE; + + type_string = (const gchar *) type; +#ifndef G_DISABLE_CHECKS + return g_variant_type_string_scan (type_string, NULL, NULL); +#else + return TRUE; +#endif +} + +/** + * g_variant_type_string_scan: + * @string: a pointer to any string + * @limit: the end of @string, or %NULL + * @endptr: location to store the end pointer, or %NULL + * @returns: %TRUE if a valid type string was found + * + * Scan for a single complete and valid GVariant type string in @string. + * The memory pointed to by @limit (or bytes beyond it) is never + * accessed. + * + * If a valid type string is found, @endptr is updated to point to the + * first character past the end of the string that was found and %TRUE + * is returned. + * + * If there is no valid type string starting at @string, or if the type + * string does not end before @limit then %FALSE is returned. + * + * For the simple case of checking if a string is a valid type string, + * see g_variant_type_string_is_valid(). + * + * Since: 2.24 + **/ +gboolean +g_variant_type_string_scan (const gchar *string, + const gchar *limit, + const gchar **endptr) +{ + g_return_val_if_fail (string != NULL, FALSE); + + if (string == limit || *string == '\0') + return FALSE; + + switch (*string++) + { + case '(': + while (string == limit || *string != ')') + if (!g_variant_type_string_scan (string, limit, &string)) + return FALSE; + + string++; + break; + + case '{': + if (string == limit || *string == '\0' || /* { */ + !strchr ("bynqihuxtdsog?", *string++) || /* key */ + !g_variant_type_string_scan (string, limit, &string) || /* value */ + string == limit || *string++ != '}') /* } */ + return FALSE; + + break; + + case 'm': case 'a': + return g_variant_type_string_scan (string, limit, endptr); + + case 'b': case 'y': case 'n': case 'q': case 'i': case 'u': + case 'x': case 't': case 'd': case 's': case 'o': case 'g': + case 'v': case 'r': case '*': case '?': case 'h': + break; + + default: + return FALSE; + } + + if (endptr != NULL) + *endptr = string; + + return TRUE; +} + +/** + * g_variant_type_string_is_valid: + * @type_string: a pointer to any string + * @returns: %TRUE if @type_string is exactly one valid type string + * + * Checks if @type_string is a valid GVariant type string. This call is + * equivalent to calling g_variant_type_string_scan() and confirming + * that the following character is a nul terminator. + * + * Since 2.24 + **/ +gboolean +g_variant_type_string_is_valid (const gchar *type_string) +{ + gchar *endptr; + + g_return_val_if_fail (type_string != NULL, FALSE); + + if (!g_variant_type_string_scan (type_string, NULL, &endptr)) + return FALSE; + + return *endptr == '\0'; +} + +/** + * g_variant_type_free: + * @type: a #GVariantType, or %NULL + * + * Frees a #GVariantType that was allocated with + * g_variant_type_copy(), g_variant_type_new() or one of the container + * type constructor functions. + * + * In the case that @type is %NULL, this function does nothing. + * + * Since 2.24 + **/ +void +g_variant_type_free (GVariantType *type) +{ + g_return_if_fail (type == NULL || g_variant_type_check (type)); + + g_free (type); +} + +/** + * g_variant_type_copy: + * @type: a #GVariantType + * @returns: a new #GVariantType + * + * Makes a copy of a #GVariantType. It is appropriate to call + * g_variant_type_free() on the return value. @type may not be %NULL. + * + * Since 2.24 + **/ +GVariantType * +g_variant_type_copy (const GVariantType *type) +{ + gsize length; + gchar *new; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + length = g_variant_type_get_string_length (type); + new = g_malloc (length + 1); + + memcpy (new, type, length); + new[length] = '\0'; + + return (GVariantType *) new; +} + +/** + * g_variant_type_new: + * @type_string: a valid GVariant type string + * @returns: a new #GVariantType + * + * Creates a new #GVariantType corresponding to the type string given + * by @type_string. It is appropriate to call g_variant_type_free() on + * the return value. + * + * It is a programmer error to call this function with an invalid type + * string. Use g_variant_type_string_is_valid() if you are unsure. + */ +GVariantType * +g_variant_type_new (const gchar *type_string) +{ + g_return_val_if_fail (type_string != NULL, NULL); + + return g_variant_type_copy (G_VARIANT_TYPE (type_string)); +} + +/** + * g_variant_type_get_string_length: + * @type: a #GVariantType + * @returns: the length of the corresponding type string + * + * Returns the length of the type string corresponding to the given + * @type. This function must be used to determine the valid extent of + * the memory region returned by g_variant_type_peek_string(). + * + * Since 2.24 + **/ +gsize +g_variant_type_get_string_length (const GVariantType *type) +{ + const gchar *type_string = (const gchar *) type; + gint brackets = 0; + gsize index = 0; + + g_return_val_if_fail (g_variant_type_check (type), 0); + + do + { + while (type_string[index] == 'a' || type_string[index] == 'm') + index++; + + if (type_string[index] == '(' || type_string[index] == '{') + brackets++; + + else if (type_string[index] == ')' || type_string[index] == '}') + brackets--; + + index++; + } + while (brackets); + + return index; +} + +/** + * g_variant_type_peek_string: + * @type: a #GVariantType + * @returns: the corresponding type string (not nul-terminated) + * + * Returns the type string corresponding to the given @type. The + * result is not nul-terminated; in order to determine its length you + * must call g_variant_type_get_string_length(). + * + * To get a nul-terminated string, see g_variant_type_dup_string(). + * + * Since 2.24 + **/ +const gchar * +g_variant_type_peek_string (const GVariantType *type) +{ + g_return_val_if_fail (g_variant_type_check (type), NULL); + + return (const gchar *) type; +} + +/** + * g_variant_type_dup_string: + * @type: a #GVariantType + * @returns: the corresponding type string + * + * Returns a newly-allocated copy of the type string corresponding to + * @type. The returned string is nul-terminated. It is appropriate to + * call g_free() on the return value. + * + * Since 2.24 + **/ +gchar * +g_variant_type_dup_string (const GVariantType *type) +{ + g_return_val_if_fail (g_variant_type_check (type), NULL); + + return g_strndup (g_variant_type_peek_string (type), + g_variant_type_get_string_length (type)); +} + +/** + * g_variant_type_is_definite: + * @type: a #GVariantType + * @returns: %TRUE if @type is definite + * + * Determines if the given @type is definite (ie: not indefinite). + * + * A type is definite if its type string does not contain any indefinite + * type characters ('*', '?', or 'r'). + * + * A #GVariant instance may not have an indefinite type, so calling + * this function on the result of g_variant_get_type() will always + * result in %TRUE being returned. Calling this function on an + * indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in + * %FALSE being returned. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_definite (const GVariantType *type) +{ + const gchar *type_string; + gsize type_length; + gsize i; + + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + type_length = g_variant_type_get_string_length (type); + type_string = g_variant_type_peek_string (type); + + for (i = 0; i < type_length; i++) + if (type_string[i] == '*' || + type_string[i] == '?' || + type_string[i] == 'r') + return FALSE; + + return TRUE; +} + +/** + * g_variant_type_is_container: + * @type: a #GVariantType + * @returns: %TRUE if @type is a container type + * + * Determines if the given @type is a container type. + * + * Container types are any array, maybe, tuple, or dictionary + * entry types plus the variant type. + * + * This function returns %TRUE for any indefinite type for which every + * definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for + * example. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_container (const GVariantType *type) +{ + gchar first_char; + + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + first_char = g_variant_type_peek_string (type)[0]; + switch (first_char) + { + case 'a': + case 'm': + case 'r': + case '(': + case '{': + case 'v': + return TRUE; + + default: + return FALSE; + } +} + +/** + * g_variant_type_is_basic: + * @type: a #GVariantType + * @returns: %TRUE if @type is a basic type + * + * Determines if the given @type is a basic type. + * + * Basic types are booleans, bytes, integers, doubles, strings, object + * paths and signatures. + * + * Only a basic type may be used as the key of a dictionary entry. + * + * This function returns %FALSE for all indefinite types except + * %G_VARIANT_TYPE_BASIC. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_basic (const GVariantType *type) +{ + gchar first_char; + + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + first_char = g_variant_type_peek_string (type)[0]; + switch (first_char) + { + case 'b': + case 'y': + case 'n': + case 'q': + case 'i': + case 'h': + case 'u': + case 't': + case 'x': + case 'd': + case 's': + case 'o': + case 'g': + case '?': + return TRUE; + + default: + return FALSE; + } +} + +/** + * g_variant_type_is_maybe: + * @type: a #GVariantType + * @returns: %TRUE if @type is a maybe type + * + * Determines if the given @type is a maybe type. This is true if the + * type string for @type starts with an 'm'. + * + * This function returns %TRUE for any indefinite type for which every + * definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for + * example. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_maybe (const GVariantType *type) +{ + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + return g_variant_type_peek_string (type)[0] == 'm'; +} + +/** + * g_variant_type_is_array: + * @type: a #GVariantType + * @returns: %TRUE if @type is an array type + * + * Determines if the given @type is an array type. This is true if the + * type string for @type starts with an 'a'. + * + * This function returns %TRUE for any indefinite type for which every + * definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for + * example. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_array (const GVariantType *type) +{ + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + return g_variant_type_peek_string (type)[0] == 'a'; +} + +/** + * g_variant_type_is_tuple: + * @type: a #GVariantType + * @returns: %TRUE if @type is a tuple type + * + * Determines if the given @type is a tuple type. This is true if the + * type string for @type starts with a '(' or if @type is + * %G_VARIANT_TYPE_TUPLE. + * + * This function returns %TRUE for any indefinite type for which every + * definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for + * example. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_tuple (const GVariantType *type) +{ + gchar type_char; + + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + type_char = g_variant_type_peek_string (type)[0]; + return type_char == 'r' || type_char == '('; +} + +/** + * g_variant_type_is_dict_entry: + * @type: a #GVariantType + * @returns: %TRUE if @type is a dictionary entry type + * + * Determines if the given @type is a dictionary entry type. This is + * true if the type string for @type starts with a '{'. + * + * This function returns %TRUE for any indefinite type for which every + * definite subtype is a dictionary entry type -- + * %G_VARIANT_TYPE_DICT_ENTRY, for example. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_dict_entry (const GVariantType *type) +{ + g_return_val_if_fail (g_variant_type_check (type), FALSE); + + return g_variant_type_peek_string (type)[0] == '{'; +} + +/** + * g_variant_type_hash: + * @type: a #GVariantType + * @returns: the hash value + * + * Hashes @type. + * + * The argument type of @type is only #gconstpointer to allow use with + * #GHashTable without function pointer casting. A valid + * #GVariantType must be provided. + * + * Since 2.24 + **/ +guint +g_variant_type_hash (gconstpointer type) +{ + const gchar *type_string; + guint value = 0; + gsize length; + gsize i; + + g_return_val_if_fail (g_variant_type_check (type), 0); + + type_string = g_variant_type_peek_string (type); + length = g_variant_type_get_string_length (type); + + for (i = 0; i < length; i++) + value = (value << 5) - value + type_string[i]; + + return value; +} + +/** + * g_variant_type_equal: + * @type1: a #GVariantType + * @type2: a #GVariantType + * @returns: %TRUE if @type1 and @type2 are exactly equal + * + * Compares @type1 and @type2 for equality. + * + * Only returns %TRUE if the types are exactly equal. Even if one type + * is an indefinite type and the other is a subtype of it, %FALSE will + * be returned if they are not exactly equal. If you want to check for + * subtypes, use g_variant_type_is_subtype_of(). + * + * The argument types of @type1 and @type2 are only #gconstpointer to + * allow use with #GHashTable without function pointer casting. For + * both arguments, a valid #GVariantType must be provided. + * + * Since 2.24 + **/ +gboolean +g_variant_type_equal (gconstpointer type1, + gconstpointer type2) +{ + const gchar *string1, *string2; + gsize size1, size2; + + g_return_val_if_fail (g_variant_type_check (type1), FALSE); + g_return_val_if_fail (g_variant_type_check (type2), FALSE); + + if (type1 == type2) + return TRUE; + + size1 = g_variant_type_get_string_length (type1); + size2 = g_variant_type_get_string_length (type2); + + if (size1 != size2) + return FALSE; + + string1 = g_variant_type_peek_string (type1); + string2 = g_variant_type_peek_string (type2); + + return memcmp (string1, string2, size1) == 0; +} + +/** + * g_variant_type_is_subtype_of: + * @type: a #GVariantType + * @supertype: a #GVariantType + * @returns: %TRUE if @type is a subtype of @supertype + * + * Checks if @type is a subtype of @supertype. + * + * This function returns %TRUE if @type is a subtype of @supertype. All + * types are considered to be subtypes of themselves. Aside from that, + * only indefinite types can have subtypes. + * + * Since 2.24 + **/ +gboolean +g_variant_type_is_subtype_of (const GVariantType *type, + const GVariantType *supertype) +{ + const gchar *supertype_string; + const gchar *supertype_end; + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), FALSE); + g_return_val_if_fail (g_variant_type_check (supertype), FALSE); + + supertype_string = g_variant_type_peek_string (supertype); + type_string = g_variant_type_peek_string (type); + + supertype_end = supertype_string + + g_variant_type_get_string_length (supertype); + + /* we know that type and supertype are both well-formed, so it's + * safe to treat this merely as a text processing problem. + */ + while (supertype_string < supertype_end) + { + char supertype_char = *supertype_string++; + + if (supertype_char == *type_string) + type_string++; + + else if (*type_string == ')') + return FALSE; + + else + { + const GVariantType *target_type = (GVariantType *) type_string; + + switch (supertype_char) + { + case 'r': + if (!g_variant_type_is_tuple (target_type)) + return FALSE; + break; + + case '*': + break; + + case '?': + if (!g_variant_type_is_basic (target_type)) + return FALSE; + break; + + default: + return FALSE; + } + + type_string += g_variant_type_get_string_length (target_type); + } + } + + return TRUE; +} + +/** + * g_variant_type_element: + * @type: an array or maybe #GVariantType + * @returns: the element type of @type + * + * Determines the element type of an array or maybe type. + * + * This function may only be used with array or maybe types. + * + * Since 2.24 + **/ +const GVariantType * +g_variant_type_element (const GVariantType *type) +{ + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + type_string = g_variant_type_peek_string (type); + + g_assert (type_string[0] == 'a' || type_string[0] == 'm'); + + return (const GVariantType *) &type_string[1]; +} + +/** + * g_variant_type_first: + * @type: a tuple or dictionary entry #GVariantType + * @returns: the first item type of @type, or %NULL + * + * Determines the first item type of a tuple or dictionary entry + * type. + * + * This function may only be used with tuple or dictionary entry types, + * but must not be used with the generic tuple type + * %G_VARIANT_TYPE_TUPLE. + * + * In the case of a dictionary entry type, this returns the type of + * the key. + * + * %NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT. + * + * This call, together with g_variant_type_next() provides an iterator + * interface over tuple and dictionary entry types. + * + * Since 2.24 + **/ +const GVariantType * +g_variant_type_first (const GVariantType *type) +{ + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + type_string = g_variant_type_peek_string (type); + g_assert (type_string[0] == '(' || type_string[0] == '{'); + + if (type_string[1] == ')') + return NULL; + + return (const GVariantType *) &type_string[1]; +} + +/** + * g_variant_type_next: + * @type: a #GVariantType from a previous call + * @returns: the next #GVariantType after @type, or %NULL + * + * Determines the next item type of a tuple or dictionary entry + * type. + * + * @type must be the result of a previous call to + * g_variant_type_first() or g_variant_type_next(). + * + * If called on the key type of a dictionary entry then this call + * returns the value type. If called on the value type of a dictionary + * entry then this call returns %NULL. + * + * For tuples, %NULL is returned when @type is the last item in a tuple. + * + * Since 2.24 + **/ +const GVariantType * +g_variant_type_next (const GVariantType *type) +{ + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + type_string = g_variant_type_peek_string (type); + type_string += g_variant_type_get_string_length (type); + + if (*type_string == ')' || *type_string == '}') + return NULL; + + return (const GVariantType *) type_string; +} + +/** + * g_variant_type_n_items: + * @type: a tuple or dictionary entry #GVariantType + * @returns: the number of items in @type + * + * Determines the number of items contained in a tuple or + * dictionary entry type. + * + * This function may only be used with tuple or dictionary entry types, + * but must not be used with the generic tuple type + * %G_VARIANT_TYPE_TUPLE. + * + * In the case of a dictionary entry type, this function will always + * return 2. + * + * Since 2.24 + **/ +gsize +g_variant_type_n_items (const GVariantType *type) +{ + gsize count = 0; + + g_return_val_if_fail (g_variant_type_check (type), 0); + + for (type = g_variant_type_first (type); + type; + type = g_variant_type_next (type)) + count++; + + return count; +} + +/** + * g_variant_type_key: + * @type: a dictionary entry #GVariantType + * @returns: the key type of the dictionary entry + * + * Determines the key type of a dictionary entry type. + * + * This function may only be used with a dictionary entry type. Other + * than the additional restriction, this call is equivalent to + * g_variant_type_first(). + * + * Since 2.24 + **/ +const GVariantType * +g_variant_type_key (const GVariantType *type) +{ + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + type_string = g_variant_type_peek_string (type); + g_assert (type_string[0] == '{'); + + return (const GVariantType *) &type_string[1]; +} + +/** + * g_variant_type_value: + * @type: a dictionary entry #GVariantType + * @returns: the value type of the dictionary entry + * + * Determines the value type of a dictionary entry type. + * + * This function may only be used with a dictionary entry type. + * + * Since 2.24 + **/ +const GVariantType * +g_variant_type_value (const GVariantType *type) +{ + const gchar *type_string; + + g_return_val_if_fail (g_variant_type_check (type), NULL); + + type_string = g_variant_type_peek_string (type); + g_assert (type_string[0] == '{'); + + return g_variant_type_next (g_variant_type_key (type)); +} + +/** + * g_variant_type_new_tuple: + * @items: an array of #GVariantTypes, one for each item + * @length: the length of @items, or -1 + * @returns: a new tuple #GVariantType + * + * Constructs a new tuple type, from @items. + * + * @length is the number of items in @items, or -1 to indicate that + * @items is %NULL-terminated. + * + * It is appropriate to call g_variant_type_free() on the return value. + * + * Since 2.24 + **/ +static GVariantType * +g_variant_type_new_tuple_slow (const GVariantType * const *items, + gint length) +{ + /* the "slow" version is needed in case the static buffer of 1024 + * bytes is exceeded when running the normal version. this will + * happen only in truly insane code, so it can be slow. + */ + GString *string; + gsize i; + + string = g_string_new ("("); + for (i = 0; i < length; i++) + { + const GVariantType *type; + gsize size; + + g_return_val_if_fail (g_variant_type_check (items[i]), NULL); + + type = items[i]; + size = g_variant_type_get_string_length (type); + g_string_append_len (string, (const gchar *) type, size); + } + g_string_append_c (string, ')'); + + return (GVariantType *) g_string_free (string, FALSE); +} + +GVariantType * +g_variant_type_new_tuple (const GVariantType * const *items, + gint length) +{ + char buffer[1024]; + gsize offset; + gsize i; + + g_return_val_if_fail (length == 0 || items != NULL, NULL); + + if (length < 0) + for (length = 0; items[length] != NULL; length++); + + offset = 0; + buffer[offset++] = '('; + + for (i = 0; i < length; i++) + { + const GVariantType *type; + gsize size; + + g_return_val_if_fail (g_variant_type_check (items[i]), NULL); + + type = items[i]; + size = g_variant_type_get_string_length (type); + + if (offset + size >= sizeof buffer) /* leave room for ')' */ + return g_variant_type_new_tuple_slow (items, length); + + memcpy (&buffer[offset], type, size); + offset += size; + } + + g_assert (offset < sizeof buffer); + buffer[offset++] = ')'; + + return (GVariantType *) g_memdup (buffer, offset); +} + +/** + * g_variant_type_new_array: + * @element: a #GVariantType + * @returns: a new array #GVariantType + * + * Constructs the type corresponding to an array of elements of the + * type @type. + * + * It is appropriate to call g_variant_type_free() on the return value. + * + * Since 2.24 + **/ +GVariantType * +g_variant_type_new_array (const GVariantType *element) +{ + gsize size; + gchar *new; + + g_return_val_if_fail (g_variant_type_check (element), NULL); + + size = g_variant_type_get_string_length (element); + new = g_malloc (size + 1); + + new[0] = 'a'; + memcpy (new + 1, element, size); + + return (GVariantType *) new; +} + +/** + * g_variant_type_new_maybe: + * @element: a #GVariantType + * @returns: a new maybe #GVariantType + * + * Constructs the type corresponding to a maybe instance containing + * type @type or Nothing. + * + * It is appropriate to call g_variant_type_free() on the return value. + * + * Since 2.24 + **/ +GVariantType * +g_variant_type_new_maybe (const GVariantType *element) +{ + gsize size; + gchar *new; + + g_return_val_if_fail (g_variant_type_check (element), NULL); + + size = g_variant_type_get_string_length (element); + new = g_malloc (size + 1); + + new[0] = 'm'; + memcpy (new + 1, element, size); + + return (GVariantType *) new; +} + +/** + * g_variant_type_new_dict_entry: + * @key: a basic #GVariantType + * @value: a #GVariantType + * @returns: a new dictionary entry #GVariantType + * + * Constructs the type corresponding to a dictionary entry with a key + * of type @key and a value of type @value. + * + * It is appropriate to call g_variant_type_free() on the return value. + * + * Since 2.24 + **/ +GVariantType * +g_variant_type_new_dict_entry (const GVariantType *key, + const GVariantType *value) +{ + gsize keysize, valsize; + gchar *new; + + g_return_val_if_fail (g_variant_type_check (key), NULL); + g_return_val_if_fail (g_variant_type_check (value), NULL); + + keysize = g_variant_type_get_string_length (key); + valsize = g_variant_type_get_string_length (value); + + new = g_malloc (1 + keysize + valsize + 1); + + new[0] = '{'; + memcpy (new + 1, key, keysize); + memcpy (new + 1 + keysize, value, valsize); + new[1 + keysize + valsize] = '}'; + + return (GVariantType *) new; +} + +/* private */ +const GVariantType * +g_variant_type_checked_ (const gchar *type_string) +{ + g_return_val_if_fail (g_variant_type_string_is_valid (type_string), NULL); + return (const GVariantType *) type_string; +} + +#define __G_VARIANT_TYPE_C__ +#include "galiasdef.c" diff --git a/glib/gvarianttype.h b/glib/gvarianttype.h new file mode 100644 index 000000000..4fbf42025 --- /dev/null +++ b/glib/gvarianttype.h @@ -0,0 +1,282 @@ +/* + * Copyright © 2007, 2008 Ryan Lortie + * Copyright © 2009, 2010 Codethink Limited + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the licence, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + * Author: Ryan Lortie <desrt@desrt.ca> + */ + +#ifndef __G_VARIANT_TYPE_H__ +#define __G_VARIANT_TYPE_H__ + +#include <glib/gmessages.h> +#include <glib/gtypes.h> + +typedef struct _GVariantType GVariantType; + +/** + * G_VARIANT_TYPE_BOOLEAN: + * + * The type of a value that can be either %TRUE or %FALSE. + **/ +#define G_VARIANT_TYPE_BOOLEAN ((const GVariantType *) "b") + +/** + * G_VARIANT_TYPE_BYTE: + * + * The type of an integer value that can range from 0 to 255. + **/ +#define G_VARIANT_TYPE_BYTE ((const GVariantType *) "y") + +/** + * G_VARIANT_TYPE_INT16: + * + * The type of an integer value that can range from -32768 to 32767. + **/ +#define G_VARIANT_TYPE_INT16 ((const GVariantType *) "n") + +/** + * G_VARIANT_TYPE_UINT16: + * + * The type of an integer value that can range from 0 to 65535. + * There were about this many people living in Toronto in the 1870s. + **/ +#define G_VARIANT_TYPE_UINT16 ((const GVariantType *) "q") + +/** + * G_VARIANT_TYPE_INT32: + * + * The type of an integer value that can range from -2147483648 to + * 2147483647. + **/ +#define G_VARIANT_TYPE_INT32 ((const GVariantType *) "i") + +/** + * G_VARIANT_TYPE_UINT32: + * + * The type of an integer value that can range from 0 to 4294967295. + * That's one number for everyone who was around in the late 1970s. + **/ +#define G_VARIANT_TYPE_UINT32 ((const GVariantType *) "u") + +/** + * G_VARIANT_TYPE_INT64: + * + * The type of an integer value that can range from + * -9223372036854775808 to 9223372036854775807. + **/ +#define G_VARIANT_TYPE_INT64 ((const GVariantType *) "x") + +/** + * G_VARIANT_TYPE_UINT64: + * + * The type of an integer value that can range from 0 to + * 18446744073709551616. That's a really big number, but a Rubik's + * cube can have a bit more than twice as many possible positions. + **/ +#define G_VARIANT_TYPE_UINT64 ((const GVariantType *) "t") + +/** + * G_VARIANT_TYPE_DOUBLE: + * + * The type of a double precision IEEE754 floating point number. + * These guys go up to about 1.80e308 (plus and minus) but miss out on + * some numbers in between. In any case, that's far greater than the + * estimated number of fundamental particles in the observable + * universe. + **/ +#define G_VARIANT_TYPE_DOUBLE ((const GVariantType *) "d") + +/** + * G_VARIANT_TYPE_STRING: + * + * The type of a string. "" is a string. %NULL is not a string. + **/ +#define G_VARIANT_TYPE_STRING ((const GVariantType *) "s") + +/** + * G_VARIANT_TYPE_OBJECT_PATH: + * + * The type of a DBus object reference. These are strings of a + * specific format used to identify objects at a given destination on + * the bus. + * + * If you are not interacting with DBus, then there is no reason to make + * use of this type. If you are, then the DBus specification contains a + * precise description of valid object paths. + **/ +#define G_VARIANT_TYPE_OBJECT_PATH ((const GVariantType *) "o") + +/** + * G_VARIANT_TYPE_SIGNATURE: + * + * The type of a DBus type signature. These are strings of a specific + * format used as type signatures for DBus methods and messages. + * + * If you are not interacting with DBus, then there is no reason to make + * use of this type. If you are, then the DBus specification contains a + * precise description of valid signature strings. + **/ +#define G_VARIANT_TYPE_SIGNATURE ((const GVariantType *) "g") + +/** + * G_VARIANT_TYPE_VARIANT: + * + * The type of a box that contains any other value (including another + * variant). + **/ +#define G_VARIANT_TYPE_VARIANT ((const GVariantType *) "v") + +/** + * G_VARIANT_TYPE_HANDLE: + * + * The type of a 32bit signed integer value, that by convention, is used + * as an index into an array of file descriptors that are sent alongside + * a DBus message. + * + * If you are not interacting with DBus, then there is no reason to make + * use of this type. + **/ +#define G_VARIANT_TYPE_HANDLE ((const GVariantType *) "h") + +/** + * G_VARIANT_TYPE_UNIT: + * + * The empty tuple type. Has only one instance. Known also as "triv" + * or "void". + **/ +#define G_VARIANT_TYPE_UNIT ((const GVariantType *) "()") + +/** + * G_VARIANT_TYPE_ANY: + * + * An indefinite type that is a supertype of every type (including + * itself). + **/ +#define G_VARIANT_TYPE_ANY ((const GVariantType *) "*") + +/** + * G_VARIANT_TYPE_BASIC: + * + * An indefinite type that is a supertype of every basic (ie: + * non-container) type. + **/ +#define G_VARIANT_TYPE_BASIC ((const GVariantType *) "?") + +/** + * G_VARIANT_TYPE_MAYBE: + * + * An indefinite type that is a supertype of every maybe type. + **/ +#define G_VARIANT_TYPE_MAYBE ((const GVariantType *) "m*") + +/** + * G_VARIANT_TYPE_ARRAY: + * + * An indefinite type that is a supertype of every array type. + **/ +#define G_VARIANT_TYPE_ARRAY ((const GVariantType *) "a*") + +/** + * G_VARIANT_TYPE_TUPLE: + * + * An indefinite type that is a supertype of every tuple type, + * regardless of the number of items in the tuple. + **/ +#define G_VARIANT_TYPE_TUPLE ((const GVariantType *) "r") + +/** + * G_VARIANT_TYPE_DICT_ENTRY: + * + * An indefinite type that is a supertype of every dictionary entry + * type. + **/ +#define G_VARIANT_TYPE_DICT_ENTRY ((const GVariantType *) "{?*}") + +/** + * G_VARIANT_TYPE_DICTIONARY: + * + * An indefinite type that is a supertype of every dictionary type -- + * that is, any array type that has an element type equal to any + * dictionary entry type. + **/ +#define G_VARIANT_TYPE_DICTIONARY ((const GVariantType *) "a{?*}") + +#ifndef G_DISABLE_CHECKS +# define G_VARIANT_TYPE(str) (g_variant_type_checked_ ((str))) +#else +# define G_VARIANT_TYPE(str) ((const GVariantType *) (str)) +#endif + +G_BEGIN_DECLS + +/* type string checking */ +gboolean g_variant_type_string_is_valid (const gchar *type_string); +gboolean g_variant_type_string_scan (const gchar *string, + const gchar *limit, + const gchar **endptr); + +/* create/destroy */ +void g_variant_type_free (GVariantType *type); +GVariantType * g_variant_type_copy (const GVariantType *type); +GVariantType * g_variant_type_new (const gchar *type_string); + +/* getters */ +gsize g_variant_type_get_string_length (const GVariantType *type); +const gchar * g_variant_type_peek_string (const GVariantType *type); +gchar * g_variant_type_dup_string (const GVariantType *type); + +/* classification */ +gboolean g_variant_type_is_definite (const GVariantType *type); +gboolean g_variant_type_is_container (const GVariantType *type); +gboolean g_variant_type_is_basic (const GVariantType *type); +gboolean g_variant_type_is_maybe (const GVariantType *type); +gboolean g_variant_type_is_array (const GVariantType *type); +gboolean g_variant_type_is_tuple (const GVariantType *type); +gboolean g_variant_type_is_dict_entry (const GVariantType *type); + +/* for hash tables */ +guint g_variant_type_hash (gconstpointer type); +gboolean g_variant_type_equal (gconstpointer type1, + gconstpointer type2); + +/* subtypes */ +gboolean g_variant_type_is_subtype_of (const GVariantType *type, + const GVariantType *supertype); + +/* type iterator interface */ +const GVariantType * g_variant_type_element (const GVariantType *type); +const GVariantType * g_variant_type_first (const GVariantType *type); +const GVariantType * g_variant_type_next (const GVariantType *type); +gsize g_variant_type_n_items (const GVariantType *type); +const GVariantType * g_variant_type_key (const GVariantType *type); +const GVariantType * g_variant_type_value (const GVariantType *type); + +/* constructors */ +GVariantType * g_variant_type_new_array (const GVariantType *element); +GVariantType * g_variant_type_new_maybe (const GVariantType *element); +GVariantType * g_variant_type_new_tuple (const GVariantType * const *items, + gint length); +GVariantType * g_variant_type_new_dict_entry (const GVariantType *key, + const GVariantType *value); + +/*< private >*/ +const GVariantType * g_variant_type_checked_ (const gchar *); + +G_END_DECLS + +#endif /* __G_VARIANT_TYPE_H__ */ |