2
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
3
"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
4
<!ENTITY % local.common.attrib "xmlns:xi CDATA #FIXED 'http://www.w3.org/2003/XInclude'">
5
<!ENTITY version SYSTEM "version.xml">
7
<refentry id="glib-GVariantType">
9
<refentrytitle role="top_of_page" id="glib-GVariantType.top_of_page">GVariantType</refentrytitle>
10
<manvolnum>3</manvolnum>
11
<refmiscinfo>GLIB Library</refmiscinfo>
15
<refname>GVariantType</refname>
16
<refpurpose>introduction to the GVariant type system</refpurpose>
19
<refsynopsisdiv id="glib-GVariantType.synopsis" role="synopsis">
20
<title role="synopsis.title">Synopsis</title>
24
#include <glib.h>
26
<link linkend="GVariantType">GVariantType</link>;
27
#define <link linkend="G-VARIANT-TYPE-BOOLEAN--CAPS">G_VARIANT_TYPE_BOOLEAN</link>
28
#define <link linkend="G-VARIANT-TYPE-BYTE--CAPS">G_VARIANT_TYPE_BYTE</link>
29
#define <link linkend="G-VARIANT-TYPE-INT16--CAPS">G_VARIANT_TYPE_INT16</link>
30
#define <link linkend="G-VARIANT-TYPE-UINT16--CAPS">G_VARIANT_TYPE_UINT16</link>
31
#define <link linkend="G-VARIANT-TYPE-INT32--CAPS">G_VARIANT_TYPE_INT32</link>
32
#define <link linkend="G-VARIANT-TYPE-UINT32--CAPS">G_VARIANT_TYPE_UINT32</link>
33
#define <link linkend="G-VARIANT-TYPE-INT64--CAPS">G_VARIANT_TYPE_INT64</link>
34
#define <link linkend="G-VARIANT-TYPE-UINT64--CAPS">G_VARIANT_TYPE_UINT64</link>
35
#define <link linkend="G-VARIANT-TYPE-HANDLE--CAPS">G_VARIANT_TYPE_HANDLE</link>
36
#define <link linkend="G-VARIANT-TYPE-DOUBLE--CAPS">G_VARIANT_TYPE_DOUBLE</link>
37
#define <link linkend="G-VARIANT-TYPE-STRING--CAPS">G_VARIANT_TYPE_STRING</link>
38
#define <link linkend="G-VARIANT-TYPE-OBJECT-PATH--CAPS">G_VARIANT_TYPE_OBJECT_PATH</link>
39
#define <link linkend="G-VARIANT-TYPE-SIGNATURE--CAPS">G_VARIANT_TYPE_SIGNATURE</link>
40
#define <link linkend="G-VARIANT-TYPE-VARIANT--CAPS">G_VARIANT_TYPE_VARIANT</link>
41
#define <link linkend="G-VARIANT-TYPE-ANY--CAPS">G_VARIANT_TYPE_ANY</link>
42
#define <link linkend="G-VARIANT-TYPE-BASIC--CAPS">G_VARIANT_TYPE_BASIC</link>
43
#define <link linkend="G-VARIANT-TYPE-MAYBE--CAPS">G_VARIANT_TYPE_MAYBE</link>
44
#define <link linkend="G-VARIANT-TYPE-ARRAY--CAPS">G_VARIANT_TYPE_ARRAY</link>
45
#define <link linkend="G-VARIANT-TYPE-TUPLE--CAPS">G_VARIANT_TYPE_TUPLE</link>
46
#define <link linkend="G-VARIANT-TYPE-UNIT--CAPS">G_VARIANT_TYPE_UNIT</link>
47
#define <link linkend="G-VARIANT-TYPE-DICT-ENTRY--CAPS">G_VARIANT_TYPE_DICT_ENTRY</link>
48
#define <link linkend="G-VARIANT-TYPE-DICTIONARY--CAPS">G_VARIANT_TYPE_DICTIONARY</link>
50
#define <link linkend="G-VARIANT-TYPE--CAPS">G_VARIANT_TYPE</link> (type_string)
51
<link linkend="void">void</link> <link linkend="g-variant-type-free">g_variant_type_free</link> (<link linkend="GVariantType">GVariantType</link> *type);
52
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-copy">g_variant_type_copy</link> (const <link linkend="GVariantType">GVariantType</link> *type);
53
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-new">g_variant_type_new</link> (const <link linkend="gchar">gchar</link> *type_string);
55
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-string-is-valid">g_variant_type_string_is_valid</link> (const <link linkend="gchar">gchar</link> *type_string);
56
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-string-scan">g_variant_type_string_scan</link> (const <link linkend="gchar">gchar</link> *string,
57
const <link linkend="gchar">gchar</link> *limit,
58
const <link linkend="gchar">gchar</link> **endptr);
59
<link linkend="gsize">gsize</link> <link linkend="g-variant-type-get-string-length">g_variant_type_get_string_length</link> (const <link linkend="GVariantType">GVariantType</link> *type);
60
const <link linkend="gchar">gchar</link> * <link linkend="g-variant-type-peek-string">g_variant_type_peek_string</link> (const <link linkend="GVariantType">GVariantType</link> *type);
61
<link linkend="gchar">gchar</link> * <link linkend="g-variant-type-dup-string">g_variant_type_dup_string</link> (const <link linkend="GVariantType">GVariantType</link> *type);
63
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-definite">g_variant_type_is_definite</link> (const <link linkend="GVariantType">GVariantType</link> *type);
64
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-container">g_variant_type_is_container</link> (const <link linkend="GVariantType">GVariantType</link> *type);
65
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-basic">g_variant_type_is_basic</link> (const <link linkend="GVariantType">GVariantType</link> *type);
66
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-maybe">g_variant_type_is_maybe</link> (const <link linkend="GVariantType">GVariantType</link> *type);
67
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-array">g_variant_type_is_array</link> (const <link linkend="GVariantType">GVariantType</link> *type);
68
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-tuple">g_variant_type_is_tuple</link> (const <link linkend="GVariantType">GVariantType</link> *type);
69
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-dict-entry">g_variant_type_is_dict_entry</link> (const <link linkend="GVariantType">GVariantType</link> *type);
70
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-variant">g_variant_type_is_variant</link> (const <link linkend="GVariantType">GVariantType</link> *type);
72
<link linkend="guint">guint</link> <link linkend="g-variant-type-hash">g_variant_type_hash</link> (<link linkend="gconstpointer">gconstpointer</link> type);
73
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-equal">g_variant_type_equal</link> (<link linkend="gconstpointer">gconstpointer</link> type1,
74
<link linkend="gconstpointer">gconstpointer</link> type2);
75
<link linkend="gboolean">gboolean</link> <link linkend="g-variant-type-is-subtype-of">g_variant_type_is_subtype_of</link> (const <link linkend="GVariantType">GVariantType</link> *type,
76
const <link linkend="GVariantType">GVariantType</link> *supertype);
78
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-new-maybe">g_variant_type_new_maybe</link> (const <link linkend="GVariantType">GVariantType</link> *element);
79
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-new-array">g_variant_type_new_array</link> (const <link linkend="GVariantType">GVariantType</link> *element);
80
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-new-tuple">g_variant_type_new_tuple</link> (const <link linkend="GVariantType">GVariantType</link> * const *items,
81
<link linkend="gint">gint</link> length);
82
<link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-new-dict-entry">g_variant_type_new_dict_entry</link> (const <link linkend="GVariantType">GVariantType</link> *key,
83
const <link linkend="GVariantType">GVariantType</link> *value);
85
const <link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-element">g_variant_type_element</link> (const <link linkend="GVariantType">GVariantType</link> *type);
86
<link linkend="gsize">gsize</link> <link linkend="g-variant-type-n-items">g_variant_type_n_items</link> (const <link linkend="GVariantType">GVariantType</link> *type);
87
const <link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-first">g_variant_type_first</link> (const <link linkend="GVariantType">GVariantType</link> *type);
88
const <link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-next">g_variant_type_next</link> (const <link linkend="GVariantType">GVariantType</link> *type);
89
const <link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-key">g_variant_type_key</link> (const <link linkend="GVariantType">GVariantType</link> *type);
90
const <link linkend="GVariantType">GVariantType</link> * <link linkend="g-variant-type-value">g_variant_type_value</link> (const <link linkend="GVariantType">GVariantType</link> *type);
102
<refsect1 id="glib-GVariantType.description" role="desc">
103
<title role="desc.title">Description</title>
105
This section introduces the GVariant type system. It is based, in
106
large part, on the DBus type system, with two major changes and some minor
107
lifting of restrictions. The <ulink
108
url='http://dbus.freedesktop.org/doc/dbus-specification.html'>DBus
109
specification</ulink>, therefore, provides a significant amount of
110
information that is useful when working with GVariant.
113
The first major change with respect to the DBus type system is the
114
introduction of maybe (or "nullable") types. Any type in GVariant can be
115
converted to a maybe type, in which case, "nothing" (or "null") becomes a
116
valid value. Maybe types have been added by introducing the
117
character "<literal>m</literal>" to type strings.
120
The second major change is that the GVariant type system supports the
121
concept of "indefinite types" -- types that are less specific than
122
the normal types found in DBus. For example, it is possible to speak
123
of "an array of any type" in GVariant, where the DBus type system
124
would require you to speak of "an array of integers" or "an array of
125
strings". Indefinite types have been added by introducing the
126
characters "<literal>*</literal>", "<literal>?</literal>" and
127
"<literal>r</literal>" to type strings.
130
Finally, all arbitrary restrictions relating to the complexity of
131
types are lifted along with the restriction that dictionary entries
132
may only appear nested inside of arrays.
135
Just as in DBus, GVariant types are described with strings ("type
136
strings"). Subject to the differences mentioned above, these strings
137
are of the same form as those found in DBus. Note, however: DBus
138
always works in terms of messages and therefore individual type
139
strings appear nowhere in its interface. Instead, "signatures"
140
are a concatenation of the strings of the type of each argument in a
141
message. GVariant deals with single values directly so GVariant type
142
strings always describe the type of exactly one value. This means
143
that a DBus signature string is generally not a valid GVariant type
144
string -- except in the case that it is the signature of a message
145
containing exactly one argument.
148
An indefinite type is similar in spirit to what may be called an
149
abstract type in other type systems. No value can exist that has an
150
indefinite type as its type, but values can exist that have types
151
that are subtypes of indefinite types. That is to say,
152
<link linkend="g-variant-get-type"><function>g_variant_get_type()</function></link> will never return an indefinite type, but
153
calling <link linkend="g-variant-is-a"><function>g_variant_is_a()</function></link> with an indefinite type may return <link linkend="TRUE--CAPS"><literal>TRUE</literal></link>.
154
For example, you can not have a value that represents "an array of no
155
particular type", but you can have an "array of integers" which
156
certainly matches the type of "an array of no particular type", since
157
"array of integers" is a subtype of "array of no particular type".
160
This is similar to how instances of abstract classes may not
161
directly exist in other type systems, but instances of their
162
non-abstract subtypes may. For example, in GTK, no object that has
163
the type of <link linkend="GtkBin"><type>GtkBin</type></link> can exist (since <link linkend="GtkBin"><type>GtkBin</type></link> is an abstract class),
164
but a <link linkend="GtkWindow"><type>GtkWindow</type></link> can certainly be instantiated, and you would say
165
that the <link linkend="GtkWindow"><type>GtkWindow</type></link> is a <link linkend="GtkBin"><type>GtkBin</type></link> (since <link linkend="GtkWindow"><type>GtkWindow</type></link> is a subclass of
166
<link linkend="GtkBin"><type>GtkBin</type></link>).
169
A detailed description of GVariant type strings is given here:
172
<refsect2 id='gvariant-typestrings'>
173
<title>GVariant Type Strings</title>
175
A GVariant type string can be any of the following:
180
any basic type string (listed below)
185
"<literal>v</literal>", "<literal>r</literal>" or
186
"<literal>*</literal>"
191
one of the characters '<literal>a</literal>' or
192
'<literal>m</literal>', followed by another type string
197
the character '<literal>(</literal>', followed by a concatenation
198
of zero or more other type strings, followed by the character
199
'<literal>)</literal>'
204
the character '<literal>{</literal>', followed by a basic type
205
string (see below), followed by another type string, followed by
206
the character '<literal>}</literal>'
211
A basic type string describes a basic type (as per
212
<link linkend="g-variant-type-is-basic"><function>g_variant_type_is_basic()</function></link>) and is always a single
213
character in length. The valid basic type strings are
214
"<literal>b</literal>", "<literal>y</literal>",
215
"<literal>n</literal>", "<literal>q</literal>",
216
"<literal>i</literal>", "<literal>u</literal>",
217
"<literal>x</literal>", "<literal>t</literal>",
218
"<literal>h</literal>", "<literal>d</literal>",
219
"<literal>s</literal>", "<literal>o</literal>",
220
"<literal>g</literal>" and "<literal>?</literal>".
223
The above definition is recursive to arbitrary depth.
224
"<literal>aaaaai</literal>" and "<literal>(ui(nq((y)))s)</literal>"
225
are both valid type strings, as is
226
"<literal>a(aa(ui)(qna{ya(yd)}))</literal>".
229
The meaning of each of the characters is as follows:
237
<emphasis role='strong'>Character</emphasis>
242
<emphasis role='strong'>Meaning</emphasis>
254
the type string of <link linkend="G-VARIANT-TYPE-BOOLEAN--CAPS"><literal>G_VARIANT_TYPE_BOOLEAN</literal></link>; a boolean value.
266
the type string of <link linkend="G-VARIANT-TYPE-BYTE--CAPS"><literal>G_VARIANT_TYPE_BYTE</literal></link>; a byte.
278
the type string of <link linkend="G-VARIANT-TYPE-INT16--CAPS"><literal>G_VARIANT_TYPE_INT16</literal></link>; a signed 16 bit
291
the type string of <link linkend="G-VARIANT-TYPE-UINT16--CAPS"><literal>G_VARIANT_TYPE_UINT16</literal></link>; an unsigned 16 bit
304
the type string of <link linkend="G-VARIANT-TYPE-INT32--CAPS"><literal>G_VARIANT_TYPE_INT32</literal></link>; a signed 32 bit
317
the type string of <link linkend="G-VARIANT-TYPE-UINT32--CAPS"><literal>G_VARIANT_TYPE_UINT32</literal></link>; an unsigned 32 bit
330
the type string of <link linkend="G-VARIANT-TYPE-INT64--CAPS"><literal>G_VARIANT_TYPE_INT64</literal></link>; a signed 64 bit
343
the type string of <link linkend="G-VARIANT-TYPE-UINT64--CAPS"><literal>G_VARIANT_TYPE_UINT64</literal></link>; an unsigned 64 bit
356
the type string of <link linkend="G-VARIANT-TYPE-HANDLE--CAPS"><literal>G_VARIANT_TYPE_HANDLE</literal></link>; a signed 32 bit
357
value that, by convention, is used as an index into an array
358
of file descriptors that are sent alongside a DBus message.
370
the type string of <link linkend="G-VARIANT-TYPE-DOUBLE--CAPS"><literal>G_VARIANT_TYPE_DOUBLE</literal></link>; a double precision
371
floating point value.
383
the type string of <link linkend="G-VARIANT-TYPE-STRING--CAPS"><literal>G_VARIANT_TYPE_STRING</literal></link>; a string.
395
the type string of <link linkend="G-VARIANT-TYPE-OBJECT-PATH--CAPS"><literal>G_VARIANT_TYPE_OBJECT_PATH</literal></link>; a string in
396
the form of a DBus object path.
408
the type string of <link linkend="G-VARIANT-TYPE-STRING--CAPS"><literal>G_VARIANT_TYPE_STRING</literal></link>; a string in the
409
form of a DBus type signature.
421
the type string of <link linkend="G-VARIANT-TYPE-BASIC--CAPS"><literal>G_VARIANT_TYPE_BASIC</literal></link>; an indefinite type
422
that is a supertype of any of the basic types.
434
the type string of <link linkend="G-VARIANT-TYPE-VARIANT--CAPS"><literal>G_VARIANT_TYPE_VARIANT</literal></link>; a container type
435
that contain any other type of value.
447
used as a prefix on another type string to mean an array of
448
that type; the type string "<literal>ai</literal>", for
449
example, is the type of an array of 32 bit signed integers.
461
used as a prefix on another type string to mean a "maybe", or
462
"nullable", version of that type; the type string
463
"<literal>ms</literal>", for example, is the type of a value
464
that maybe contains a string, or maybe contains nothing.
471
<literal>()</literal>
476
used to enclose zero or more other concatenated type strings
477
to create a tuple type; the type string
478
"<literal>(is)</literal>", for example, is the type of a pair
479
of an integer and a string.
491
the type string of <link linkend="G-VARIANT-TYPE-TUPLE--CAPS"><literal>G_VARIANT_TYPE_TUPLE</literal></link>; an indefinite type
492
that is a supertype of any tuple type, regardless of the
500
<literal>{}</literal>
505
used to enclose a basic type string concatenated with another
506
type string to create a dictionary entry type, which usually
507
appears inside of an array to form a dictionary; the type
508
string "<literal>a{sd}</literal>", for example, is the type of
509
a dictionary that maps strings to double precision floating
513
The first type (the basic type) is the key type and the second
514
type is the value type. The reason that the first type is
515
restricted to being a basic type is so that it can easily be
528
the type string of <link linkend="G-VARIANT-TYPE-ANY--CAPS"><literal>G_VARIANT_TYPE_ANY</literal></link>; the indefinite type
529
that is a supertype of all types. Note that, as with all type
530
strings, this character represents exactly one type. It
531
cannot be used inside of tuples to mean "any number of items".
539
Any type string of a container that contains an indefinite type is,
540
itself, an indefinite type. For example, the type string
541
"<literal>a*</literal>" (corresponding to <link linkend="G-VARIANT-TYPE-ARRAY--CAPS"><literal>G_VARIANT_TYPE_ARRAY</literal></link>) is
542
an indefinite type that is a supertype of every array type.
543
"<literal>(*s)</literal>" is a supertype of all tuples that
544
contain exactly two items where the second item is a string.
547
"<literal>a{?*}</literal>" is an indefinite type that is a
548
supertype of all arrays containing dictionary entries where the key
549
is any basic type and the value is any type at all. This is, by
550
definition, a dictionary, so this type string corresponds to
551
<link linkend="G-VARIANT-TYPE-DICTIONARY--CAPS"><literal>G_VARIANT_TYPE_DICTIONARY</literal></link>. Note that, due to the restriction that
552
the key of a dictionary entry must be a basic type,
553
"<literal>{**}</literal>" is not a valid type string.
560
<refsect1 id="glib-GVariantType.details" role="details">
561
<title role="details.title">Details</title>
562
<refsect2 id="GVariantType" role="struct">
563
<title>GVariantType</title>
564
<indexterm zone="GVariantType"><primary sortas="VariantType">GVariantType</primary></indexterm><programlisting>typedef struct _GVariantType GVariantType;</programlisting>
566
A type in the GVariant type system.
569
Two types may not be compared by value; use <link linkend="g-variant-type-equal"><function>g_variant_type_equal()</function></link> or
570
<link linkend="g-variant-type-is-subtype"><function>g_variant_type_is_subtype()</function></link>. May be copied using
571
<link linkend="g-variant-type-copy"><function>g_variant_type_copy()</function></link> and freed using <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link>.</para>
574
<refsect2 id="G-VARIANT-TYPE-BOOLEAN--CAPS" role="macro">
575
<title>G_VARIANT_TYPE_BOOLEAN</title>
576
<indexterm zone="G-VARIANT-TYPE-BOOLEAN--CAPS"><primary sortas="VARIANT_TYPE_BOOLEAN">G_VARIANT_TYPE_BOOLEAN</primary></indexterm><programlisting>#define G_VARIANT_TYPE_BOOLEAN ((const GVariantType *) "b")
579
The type of a value that can be either <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> or <link linkend="FALSE--CAPS"><literal>FALSE</literal></link>.</para>
582
<refsect2 id="G-VARIANT-TYPE-BYTE--CAPS" role="macro">
583
<title>G_VARIANT_TYPE_BYTE</title>
584
<indexterm zone="G-VARIANT-TYPE-BYTE--CAPS"><primary sortas="VARIANT_TYPE_BYTE">G_VARIANT_TYPE_BYTE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_BYTE ((const GVariantType *) "y")
587
The type of an integer value that can range from 0 to 255.</para>
590
<refsect2 id="G-VARIANT-TYPE-INT16--CAPS" role="macro">
591
<title>G_VARIANT_TYPE_INT16</title>
592
<indexterm zone="G-VARIANT-TYPE-INT16--CAPS"><primary sortas="VARIANT_TYPE_INT16">G_VARIANT_TYPE_INT16</primary></indexterm><programlisting>#define G_VARIANT_TYPE_INT16 ((const GVariantType *) "n")
595
The type of an integer value that can range from -32768 to 32767.</para>
598
<refsect2 id="G-VARIANT-TYPE-UINT16--CAPS" role="macro">
599
<title>G_VARIANT_TYPE_UINT16</title>
600
<indexterm zone="G-VARIANT-TYPE-UINT16--CAPS"><primary sortas="VARIANT_TYPE_UINT16">G_VARIANT_TYPE_UINT16</primary></indexterm><programlisting>#define G_VARIANT_TYPE_UINT16 ((const GVariantType *) "q")
603
The type of an integer value that can range from 0 to 65535.
604
There were about this many people living in Toronto in the 1870s.</para>
607
<refsect2 id="G-VARIANT-TYPE-INT32--CAPS" role="macro">
608
<title>G_VARIANT_TYPE_INT32</title>
609
<indexterm zone="G-VARIANT-TYPE-INT32--CAPS"><primary sortas="VARIANT_TYPE_INT32">G_VARIANT_TYPE_INT32</primary></indexterm><programlisting>#define G_VARIANT_TYPE_INT32 ((const GVariantType *) "i")
612
The type of an integer value that can range from -2147483648 to
616
<refsect2 id="G-VARIANT-TYPE-UINT32--CAPS" role="macro">
617
<title>G_VARIANT_TYPE_UINT32</title>
618
<indexterm zone="G-VARIANT-TYPE-UINT32--CAPS"><primary sortas="VARIANT_TYPE_UINT32">G_VARIANT_TYPE_UINT32</primary></indexterm><programlisting>#define G_VARIANT_TYPE_UINT32 ((const GVariantType *) "u")
621
The type of an integer value that can range from 0 to 4294967295.
622
That's one number for everyone who was around in the late 1970s.</para>
625
<refsect2 id="G-VARIANT-TYPE-INT64--CAPS" role="macro">
626
<title>G_VARIANT_TYPE_INT64</title>
627
<indexterm zone="G-VARIANT-TYPE-INT64--CAPS"><primary sortas="VARIANT_TYPE_INT64">G_VARIANT_TYPE_INT64</primary></indexterm><programlisting>#define G_VARIANT_TYPE_INT64 ((const GVariantType *) "x")
630
The type of an integer value that can range from
631
-9223372036854775808 to 9223372036854775807.</para>
634
<refsect2 id="G-VARIANT-TYPE-UINT64--CAPS" role="macro">
635
<title>G_VARIANT_TYPE_UINT64</title>
636
<indexterm zone="G-VARIANT-TYPE-UINT64--CAPS"><primary sortas="VARIANT_TYPE_UINT64">G_VARIANT_TYPE_UINT64</primary></indexterm><programlisting>#define G_VARIANT_TYPE_UINT64 ((const GVariantType *) "t")
639
The type of an integer value that can range from 0 to
640
18446744073709551616. That's a really big number, but a Rubik's
641
cube can have a bit more than twice as many possible positions.</para>
644
<refsect2 id="G-VARIANT-TYPE-HANDLE--CAPS" role="macro">
645
<title>G_VARIANT_TYPE_HANDLE</title>
646
<indexterm zone="G-VARIANT-TYPE-HANDLE--CAPS"><primary sortas="VARIANT_TYPE_HANDLE">G_VARIANT_TYPE_HANDLE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_HANDLE ((const GVariantType *) "h")
649
The type of a 32bit signed integer value, that by convention, is used
650
as an index into an array of file descriptors that are sent alongside
654
If you are not interacting with DBus, then there is no reason to make
655
use of this type.</para>
658
<refsect2 id="G-VARIANT-TYPE-DOUBLE--CAPS" role="macro">
659
<title>G_VARIANT_TYPE_DOUBLE</title>
660
<indexterm zone="G-VARIANT-TYPE-DOUBLE--CAPS"><primary sortas="VARIANT_TYPE_DOUBLE">G_VARIANT_TYPE_DOUBLE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_DOUBLE ((const GVariantType *) "d")
663
The type of a double precision IEEE754 floating point number.
664
These guys go up to about 1.80e308 (plus and minus) but miss out on
665
some numbers in between. In any case, that's far greater than the
666
estimated number of fundamental particles in the observable
670
<refsect2 id="G-VARIANT-TYPE-STRING--CAPS" role="macro">
671
<title>G_VARIANT_TYPE_STRING</title>
672
<indexterm zone="G-VARIANT-TYPE-STRING--CAPS"><primary sortas="VARIANT_TYPE_STRING">G_VARIANT_TYPE_STRING</primary></indexterm><programlisting>#define G_VARIANT_TYPE_STRING ((const GVariantType *) "s")
675
The type of a string. "" is a string. <link linkend="NULL--CAPS"><literal>NULL</literal></link> is not a string.</para>
678
<refsect2 id="G-VARIANT-TYPE-OBJECT-PATH--CAPS" role="macro">
679
<title>G_VARIANT_TYPE_OBJECT_PATH</title>
680
<indexterm zone="G-VARIANT-TYPE-OBJECT-PATH--CAPS"><primary sortas="VARIANT_TYPE_OBJECT_PATH">G_VARIANT_TYPE_OBJECT_PATH</primary></indexterm><programlisting>#define G_VARIANT_TYPE_OBJECT_PATH ((const GVariantType *) "o")
683
The type of a DBus object reference. These are strings of a
684
specific format used to identify objects at a given destination on
688
If you are not interacting with DBus, then there is no reason to make
689
use of this type. If you are, then the DBus specification contains a
690
precise description of valid object paths.</para>
693
<refsect2 id="G-VARIANT-TYPE-SIGNATURE--CAPS" role="macro">
694
<title>G_VARIANT_TYPE_SIGNATURE</title>
695
<indexterm zone="G-VARIANT-TYPE-SIGNATURE--CAPS"><primary sortas="VARIANT_TYPE_SIGNATURE">G_VARIANT_TYPE_SIGNATURE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_SIGNATURE ((const GVariantType *) "g")
698
The type of a DBus type signature. These are strings of a specific
699
format used as type signatures for DBus methods and messages.
702
If you are not interacting with DBus, then there is no reason to make
703
use of this type. If you are, then the DBus specification contains a
704
precise description of valid signature strings.</para>
707
<refsect2 id="G-VARIANT-TYPE-VARIANT--CAPS" role="macro">
708
<title>G_VARIANT_TYPE_VARIANT</title>
709
<indexterm zone="G-VARIANT-TYPE-VARIANT--CAPS"><primary sortas="VARIANT_TYPE_VARIANT">G_VARIANT_TYPE_VARIANT</primary></indexterm><programlisting>#define G_VARIANT_TYPE_VARIANT ((const GVariantType *) "v")
712
The type of a box that contains any other value (including another
716
<refsect2 id="G-VARIANT-TYPE-ANY--CAPS" role="macro">
717
<title>G_VARIANT_TYPE_ANY</title>
718
<indexterm zone="G-VARIANT-TYPE-ANY--CAPS"><primary sortas="VARIANT_TYPE_ANY">G_VARIANT_TYPE_ANY</primary></indexterm><programlisting>#define G_VARIANT_TYPE_ANY ((const GVariantType *) "*")
721
An indefinite type that is a supertype of every type (including
725
<refsect2 id="G-VARIANT-TYPE-BASIC--CAPS" role="macro">
726
<title>G_VARIANT_TYPE_BASIC</title>
727
<indexterm zone="G-VARIANT-TYPE-BASIC--CAPS"><primary sortas="VARIANT_TYPE_BASIC">G_VARIANT_TYPE_BASIC</primary></indexterm><programlisting>#define G_VARIANT_TYPE_BASIC ((const GVariantType *) "?")
730
An indefinite type that is a supertype of every basic (ie:
731
non-container) type.</para>
734
<refsect2 id="G-VARIANT-TYPE-MAYBE--CAPS" role="macro">
735
<title>G_VARIANT_TYPE_MAYBE</title>
736
<indexterm zone="G-VARIANT-TYPE-MAYBE--CAPS"><primary sortas="VARIANT_TYPE_MAYBE">G_VARIANT_TYPE_MAYBE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_MAYBE ((const GVariantType *) "m*")
739
An indefinite type that is a supertype of every maybe type.</para>
742
<refsect2 id="G-VARIANT-TYPE-ARRAY--CAPS" role="macro">
743
<title>G_VARIANT_TYPE_ARRAY</title>
744
<indexterm zone="G-VARIANT-TYPE-ARRAY--CAPS"><primary sortas="VARIANT_TYPE_ARRAY">G_VARIANT_TYPE_ARRAY</primary></indexterm><programlisting>#define G_VARIANT_TYPE_ARRAY ((const GVariantType *) "a*")
747
An indefinite type that is a supertype of every array type.</para>
750
<refsect2 id="G-VARIANT-TYPE-TUPLE--CAPS" role="macro">
751
<title>G_VARIANT_TYPE_TUPLE</title>
752
<indexterm zone="G-VARIANT-TYPE-TUPLE--CAPS"><primary sortas="VARIANT_TYPE_TUPLE">G_VARIANT_TYPE_TUPLE</primary></indexterm><programlisting>#define G_VARIANT_TYPE_TUPLE ((const GVariantType *) "r")
755
An indefinite type that is a supertype of every tuple type,
756
regardless of the number of items in the tuple.</para>
759
<refsect2 id="G-VARIANT-TYPE-UNIT--CAPS" role="macro">
760
<title>G_VARIANT_TYPE_UNIT</title>
761
<indexterm zone="G-VARIANT-TYPE-UNIT--CAPS"><primary sortas="VARIANT_TYPE_UNIT">G_VARIANT_TYPE_UNIT</primary></indexterm><programlisting>#define G_VARIANT_TYPE_UNIT ((const GVariantType *) "()")
764
The empty tuple type. Has only one instance. Known also as "triv"
768
<refsect2 id="G-VARIANT-TYPE-DICT-ENTRY--CAPS" role="macro">
769
<title>G_VARIANT_TYPE_DICT_ENTRY</title>
770
<indexterm zone="G-VARIANT-TYPE-DICT-ENTRY--CAPS"><primary sortas="VARIANT_TYPE_DICT_ENTRY">G_VARIANT_TYPE_DICT_ENTRY</primary></indexterm><programlisting>#define G_VARIANT_TYPE_DICT_ENTRY ((const GVariantType *) "{?*}")
773
An indefinite type that is a supertype of every dictionary entry
777
<refsect2 id="G-VARIANT-TYPE-DICTIONARY--CAPS" role="macro">
778
<title>G_VARIANT_TYPE_DICTIONARY</title>
779
<indexterm zone="G-VARIANT-TYPE-DICTIONARY--CAPS"><primary sortas="VARIANT_TYPE_DICTIONARY">G_VARIANT_TYPE_DICTIONARY</primary></indexterm><programlisting>#define G_VARIANT_TYPE_DICTIONARY ((const GVariantType *) "a{?*}")
782
An indefinite type that is a supertype of every dictionary type --
783
that is, any array type that has an element type equal to any
784
dictionary entry type.</para>
787
<refsect2 id="G-VARIANT-TYPE--CAPS" role="macro">
788
<title>G_VARIANT_TYPE()</title>
789
<indexterm zone="G-VARIANT-TYPE--CAPS"><primary sortas="VARIANT_TYPE">G_VARIANT_TYPE</primary></indexterm><programlisting>#define G_VARIANT_TYPE(type_string)</programlisting>
791
Converts a string to a const <link linkend="GVariantType"><type>GVariantType</type></link>. Depending on the
792
current debugging level, this function may perform a runtime check
793
to ensure that <parameter>string</parameter> is a valid GVariant type string.
796
It is always a programmer error to use this macro with an invalid
802
</para><variablelist role="params">
803
<varlistentry><term><parameter>type_string</parameter> :</term>
804
<listitem><simpara> a well-formed <link linkend="GVariantType"><type>GVariantType</type></link> type string
805
</simpara></listitem></varlistentry>
806
</variablelist></refsect2>
807
<refsect2 id="g-variant-type-free" role="function">
808
<title>g_variant_type_free ()</title>
809
<indexterm zone="g-variant-type-free"><primary sortas="variant_type_free">g_variant_type_free</primary></indexterm><programlisting><link linkend="void">void</link> g_variant_type_free (<link linkend="GVariantType">GVariantType</link> *type);</programlisting>
811
Frees a <link linkend="GVariantType"><type>GVariantType</type></link> that was allocated with
812
<link linkend="g-variant-type-copy"><function>g_variant_type_copy()</function></link>, <link linkend="g-variant-type-new"><function>g_variant_type_new()</function></link> or one of the container
813
type constructor functions.
816
In the case that <parameter>type</parameter> is <link linkend="NULL--CAPS"><literal>NULL</literal></link>, this function does nothing.
821
</para><variablelist role="params">
822
<varlistentry><term><parameter>type</parameter> :</term>
823
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>, or <link linkend="NULL--CAPS"><literal>NULL</literal></link>
824
</simpara></listitem></varlistentry>
825
</variablelist></refsect2>
826
<refsect2 id="g-variant-type-copy" role="function">
827
<title>g_variant_type_copy ()</title>
828
<indexterm zone="g-variant-type-copy"><primary sortas="variant_type_copy">g_variant_type_copy</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_copy (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
830
Makes a copy of a <link linkend="GVariantType"><type>GVariantType</type></link>. It is appropriate to call
831
<link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on the return value. <parameter>type</parameter> may not be <link linkend="NULL--CAPS"><literal>NULL</literal></link>.
836
</para><variablelist role="params">
837
<varlistentry><term><parameter>type</parameter> :</term>
838
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
839
</simpara></listitem></varlistentry>
840
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new <link linkend="GVariantType"><type>GVariantType</type></link>
841
</simpara></listitem></varlistentry>
842
</variablelist></refsect2>
843
<refsect2 id="g-variant-type-new" role="function" condition="since:2.24">
844
<title>g_variant_type_new ()</title>
845
<indexterm zone="g-variant-type-new" role="2.24"><primary sortas="variant_type_new">g_variant_type_new</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_new (const <link linkend="gchar">gchar</link> *type_string);</programlisting>
847
Creates a new <link linkend="GVariantType"><type>GVariantType</type></link> corresponding to the type string given
848
by <parameter>type_string</parameter>. It is appropriate to call <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on
852
It is a programmer error to call this function with an invalid type
853
string. Use <link linkend="g-variant-type-string-is-valid"><function>g_variant_type_string_is_valid()</function></link> if you are unsure.</para>
855
</para><variablelist role="params">
856
<varlistentry><term><parameter>type_string</parameter> :</term>
857
<listitem><simpara> a valid GVariant type string
858
</simpara></listitem></varlistentry>
859
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new <link linkend="GVariantType"><type>GVariantType</type></link>
860
</simpara></listitem></varlistentry>
861
</variablelist><para role="since">Since 2.24</para></refsect2>
862
<refsect2 id="g-variant-type-string-is-valid" role="function">
863
<title>g_variant_type_string_is_valid ()</title>
864
<indexterm zone="g-variant-type-string-is-valid"><primary sortas="variant_type_string_is_valid">g_variant_type_string_is_valid</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_string_is_valid (const <link linkend="gchar">gchar</link> *type_string);</programlisting>
866
Checks if <parameter>type_string</parameter> is a valid GVariant type string. This call is
867
equivalent to calling <link linkend="g-variant-type-string-scan"><function>g_variant_type_string_scan()</function></link> and confirming
868
that the following character is a nul terminator.
873
</para><variablelist role="params">
874
<varlistentry><term><parameter>type_string</parameter> :</term>
875
<listitem><simpara> a pointer to any string
876
</simpara></listitem></varlistentry>
877
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type_string</parameter> is exactly one valid type string
878
</simpara></listitem></varlistentry>
879
</variablelist></refsect2>
880
<refsect2 id="g-variant-type-string-scan" role="function" condition="since:2.24">
881
<title>g_variant_type_string_scan ()</title>
882
<indexterm zone="g-variant-type-string-scan" role="2.24"><primary sortas="variant_type_string_scan">g_variant_type_string_scan</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_string_scan (const <link linkend="gchar">gchar</link> *string,
883
const <link linkend="gchar">gchar</link> *limit,
884
const <link linkend="gchar">gchar</link> **endptr);</programlisting>
886
Scan for a single complete and valid GVariant type string in <parameter>string</parameter>.
887
The memory pointed to by <parameter>limit</parameter> (or bytes beyond it) is never
891
If a valid type string is found, <parameter>endptr</parameter> is updated to point to the
892
first character past the end of the string that was found and <link linkend="TRUE--CAPS"><literal>TRUE</literal></link>
896
If there is no valid type string starting at <parameter>string</parameter>, or if the type
897
string does not end before <parameter>limit</parameter> then <link linkend="FALSE--CAPS"><literal>FALSE</literal></link> is returned.
900
For the simple case of checking if a string is a valid type string,
901
see <link linkend="g-variant-type-string-is-valid"><function>g_variant_type_string_is_valid()</function></link>.</para>
903
</para><variablelist role="params">
904
<varlistentry><term><parameter>string</parameter> :</term>
905
<listitem><simpara> a pointer to any string
906
</simpara></listitem></varlistentry>
907
<varlistentry><term><parameter>limit</parameter> :</term>
908
<listitem><simpara> the end of <parameter>string</parameter>, or <link linkend="NULL--CAPS"><literal>NULL</literal></link>
909
</simpara></listitem></varlistentry>
910
<varlistentry><term><parameter>endptr</parameter> :</term>
911
<listitem><simpara> location to store the end pointer, or <link linkend="NULL--CAPS"><literal>NULL</literal></link>
912
</simpara></listitem></varlistentry>
913
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if a valid type string was found
914
</simpara></listitem></varlistentry>
915
</variablelist><para role="since">Since 2.24</para></refsect2>
916
<refsect2 id="g-variant-type-get-string-length" role="function">
917
<title>g_variant_type_get_string_length ()</title>
918
<indexterm zone="g-variant-type-get-string-length"><primary sortas="variant_type_get_string_length">g_variant_type_get_string_length</primary></indexterm><programlisting><link linkend="gsize">gsize</link> g_variant_type_get_string_length (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
920
Returns the length of the type string corresponding to the given
921
<parameter>type</parameter>. This function must be used to determine the valid extent of
922
the memory region returned by <link linkend="g-variant-type-peek-string"><function>g_variant_type_peek_string()</function></link>.
927
</para><variablelist role="params">
928
<varlistentry><term><parameter>type</parameter> :</term>
929
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
930
</simpara></listitem></varlistentry>
931
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the length of the corresponding type string
932
</simpara></listitem></varlistentry>
933
</variablelist></refsect2>
934
<refsect2 id="g-variant-type-peek-string" role="function">
935
<title>g_variant_type_peek_string ()</title>
936
<indexterm zone="g-variant-type-peek-string"><primary sortas="variant_type_peek_string">g_variant_type_peek_string</primary></indexterm><programlisting>const <link linkend="gchar">gchar</link> * g_variant_type_peek_string (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
938
Returns the type string corresponding to the given <parameter>type</parameter>. The
939
result is not nul-terminated; in order to determine its length you
940
must call <link linkend="g-variant-type-get-string-length"><function>g_variant_type_get_string_length()</function></link>.
943
To get a nul-terminated string, see <link linkend="g-variant-type-dup-string"><function>g_variant_type_dup_string()</function></link>.
948
</para><variablelist role="params">
949
<varlistentry><term><parameter>type</parameter> :</term>
950
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
951
</simpara></listitem></varlistentry>
952
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the corresponding type string (not nul-terminated)
953
</simpara></listitem></varlistentry>
954
</variablelist></refsect2>
955
<refsect2 id="g-variant-type-dup-string" role="function">
956
<title>g_variant_type_dup_string ()</title>
957
<indexterm zone="g-variant-type-dup-string"><primary sortas="variant_type_dup_string">g_variant_type_dup_string</primary></indexterm><programlisting><link linkend="gchar">gchar</link> * g_variant_type_dup_string (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
959
Returns a newly-allocated copy of the type string corresponding to
960
<parameter>type</parameter>. The returned string is nul-terminated. It is appropriate to
961
call <link linkend="g-free"><function>g_free()</function></link> on the return value.
966
</para><variablelist role="params">
967
<varlistentry><term><parameter>type</parameter> :</term>
968
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
969
</simpara></listitem></varlistentry>
970
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the corresponding type string
971
</simpara></listitem></varlistentry>
972
</variablelist></refsect2>
973
<refsect2 id="g-variant-type-is-definite" role="function">
974
<title>g_variant_type_is_definite ()</title>
975
<indexterm zone="g-variant-type-is-definite"><primary sortas="variant_type_is_definite">g_variant_type_is_definite</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_definite (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
977
Determines if the given <parameter>type</parameter> is definite (ie: not indefinite).
980
A type is definite if its type string does not contain any indefinite
981
type characters ('*', '?', or 'r').
984
A <link linkend="GVariant"><type>GVariant</type></link> instance may not have an indefinite type, so calling
985
this function on the result of <link linkend="g-variant-get-type"><function>g_variant_get_type()</function></link> will always
986
result in <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> being returned. Calling this function on an
987
indefinite type like <link linkend="G-VARIANT-TYPE-ARRAY--CAPS"><literal>G_VARIANT_TYPE_ARRAY</literal></link>, however, will result in
988
<link linkend="FALSE--CAPS"><literal>FALSE</literal></link> being returned.
993
</para><variablelist role="params">
994
<varlistentry><term><parameter>type</parameter> :</term>
995
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
996
</simpara></listitem></varlistentry>
997
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is definite
998
</simpara></listitem></varlistentry>
999
</variablelist></refsect2>
1000
<refsect2 id="g-variant-type-is-container" role="function">
1001
<title>g_variant_type_is_container ()</title>
1002
<indexterm zone="g-variant-type-is-container"><primary sortas="variant_type_is_container">g_variant_type_is_container</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_container (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1004
Determines if the given <parameter>type</parameter> is a container type.
1007
Container types are any array, maybe, tuple, or dictionary
1008
entry types plus the variant type.
1011
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> for any indefinite type for which every
1012
definite subtype is a container -- <link linkend="G-VARIANT-TYPE-ARRAY--CAPS"><literal>G_VARIANT_TYPE_ARRAY</literal></link>, for
1018
</para><variablelist role="params">
1019
<varlistentry><term><parameter>type</parameter> :</term>
1020
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1021
</simpara></listitem></varlistentry>
1022
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a container type
1023
</simpara></listitem></varlistentry>
1024
</variablelist></refsect2>
1025
<refsect2 id="g-variant-type-is-basic" role="function">
1026
<title>g_variant_type_is_basic ()</title>
1027
<indexterm zone="g-variant-type-is-basic"><primary sortas="variant_type_is_basic">g_variant_type_is_basic</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_basic (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1029
Determines if the given <parameter>type</parameter> is a basic type.
1032
Basic types are booleans, bytes, integers, doubles, strings, object
1033
paths and signatures.
1036
Only a basic type may be used as the key of a dictionary entry.
1039
This function returns <link linkend="FALSE--CAPS"><literal>FALSE</literal></link> for all indefinite types except
1040
<link linkend="G-VARIANT-TYPE-BASIC--CAPS"><literal>G_VARIANT_TYPE_BASIC</literal></link>.
1045
</para><variablelist role="params">
1046
<varlistentry><term><parameter>type</parameter> :</term>
1047
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1048
</simpara></listitem></varlistentry>
1049
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a basic type
1050
</simpara></listitem></varlistentry>
1051
</variablelist></refsect2>
1052
<refsect2 id="g-variant-type-is-maybe" role="function">
1053
<title>g_variant_type_is_maybe ()</title>
1054
<indexterm zone="g-variant-type-is-maybe"><primary sortas="variant_type_is_maybe">g_variant_type_is_maybe</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_maybe (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1056
Determines if the given <parameter>type</parameter> is a maybe type. This is true if the
1057
type string for <parameter>type</parameter> starts with an 'm'.
1060
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> for any indefinite type for which every
1061
definite subtype is a maybe type -- <link linkend="G-VARIANT-TYPE-MAYBE--CAPS"><literal>G_VARIANT_TYPE_MAYBE</literal></link>, for
1067
</para><variablelist role="params">
1068
<varlistentry><term><parameter>type</parameter> :</term>
1069
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1070
</simpara></listitem></varlistentry>
1071
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a maybe type
1072
</simpara></listitem></varlistentry>
1073
</variablelist></refsect2>
1074
<refsect2 id="g-variant-type-is-array" role="function">
1075
<title>g_variant_type_is_array ()</title>
1076
<indexterm zone="g-variant-type-is-array"><primary sortas="variant_type_is_array">g_variant_type_is_array</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_array (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1078
Determines if the given <parameter>type</parameter> is an array type. This is true if the
1079
type string for <parameter>type</parameter> starts with an 'a'.
1082
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> for any indefinite type for which every
1083
definite subtype is an array type -- <link linkend="G-VARIANT-TYPE-ARRAY--CAPS"><literal>G_VARIANT_TYPE_ARRAY</literal></link>, for
1089
</para><variablelist role="params">
1090
<varlistentry><term><parameter>type</parameter> :</term>
1091
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1092
</simpara></listitem></varlistentry>
1093
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is an array type
1094
</simpara></listitem></varlistentry>
1095
</variablelist></refsect2>
1096
<refsect2 id="g-variant-type-is-tuple" role="function">
1097
<title>g_variant_type_is_tuple ()</title>
1098
<indexterm zone="g-variant-type-is-tuple"><primary sortas="variant_type_is_tuple">g_variant_type_is_tuple</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_tuple (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1100
Determines if the given <parameter>type</parameter> is a tuple type. This is true if the
1101
type string for <parameter>type</parameter> starts with a '(' or if <parameter>type</parameter> is
1102
<link linkend="G-VARIANT-TYPE-TUPLE--CAPS"><literal>G_VARIANT_TYPE_TUPLE</literal></link>.
1105
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> for any indefinite type for which every
1106
definite subtype is a tuple type -- <link linkend="G-VARIANT-TYPE-TUPLE--CAPS"><literal>G_VARIANT_TYPE_TUPLE</literal></link>, for
1112
</para><variablelist role="params">
1113
<varlistentry><term><parameter>type</parameter> :</term>
1114
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1115
</simpara></listitem></varlistentry>
1116
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a tuple type
1117
</simpara></listitem></varlistentry>
1118
</variablelist></refsect2>
1119
<refsect2 id="g-variant-type-is-dict-entry" role="function">
1120
<title>g_variant_type_is_dict_entry ()</title>
1121
<indexterm zone="g-variant-type-is-dict-entry"><primary sortas="variant_type_is_dict_entry">g_variant_type_is_dict_entry</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_dict_entry (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1123
Determines if the given <parameter>type</parameter> is a dictionary entry type. This is
1124
true if the type string for <parameter>type</parameter> starts with a '{'.
1127
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> for any indefinite type for which every
1128
definite subtype is a dictionary entry type --
1129
<link linkend="G-VARIANT-TYPE-DICT-ENTRY--CAPS"><literal>G_VARIANT_TYPE_DICT_ENTRY</literal></link>, for example.
1134
</para><variablelist role="params">
1135
<varlistentry><term><parameter>type</parameter> :</term>
1136
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1137
</simpara></listitem></varlistentry>
1138
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a dictionary entry type
1139
</simpara></listitem></varlistentry>
1140
</variablelist></refsect2>
1141
<refsect2 id="g-variant-type-is-variant" role="function">
1142
<title>g_variant_type_is_variant ()</title>
1143
<indexterm zone="g-variant-type-is-variant"><primary sortas="variant_type_is_variant">g_variant_type_is_variant</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_variant (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1145
Determines if the given <parameter>type</parameter> is the variant type.
1150
</para><variablelist role="params">
1151
<varlistentry><term><parameter>type</parameter> :</term>
1152
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1153
</simpara></listitem></varlistentry>
1154
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is the variant type
1155
</simpara></listitem></varlistentry>
1156
</variablelist></refsect2>
1157
<refsect2 id="g-variant-type-hash" role="function">
1158
<title>g_variant_type_hash ()</title>
1159
<indexterm zone="g-variant-type-hash"><primary sortas="variant_type_hash">g_variant_type_hash</primary></indexterm><programlisting><link linkend="guint">guint</link> g_variant_type_hash (<link linkend="gconstpointer">gconstpointer</link> type);</programlisting>
1161
Hashes <parameter>type</parameter>.
1164
The argument type of <parameter>type</parameter> is only <link linkend="gconstpointer"><type>gconstpointer</type></link> to allow use with
1165
<link linkend="GHashTable"><type>GHashTable</type></link> without function pointer casting. A valid
1166
<link linkend="GVariantType"><type>GVariantType</type></link> must be provided.
1171
</para><variablelist role="params">
1172
<varlistentry><term><parameter>type</parameter> :</term>
1173
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1174
</simpara></listitem></varlistentry>
1175
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the hash value
1176
</simpara></listitem></varlistentry>
1177
</variablelist></refsect2>
1178
<refsect2 id="g-variant-type-equal" role="function">
1179
<title>g_variant_type_equal ()</title>
1180
<indexterm zone="g-variant-type-equal"><primary sortas="variant_type_equal">g_variant_type_equal</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_equal (<link linkend="gconstpointer">gconstpointer</link> type1,
1181
<link linkend="gconstpointer">gconstpointer</link> type2);</programlisting>
1183
Compares <parameter>type1</parameter> and <parameter>type2</parameter> for equality.
1186
Only returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if the types are exactly equal. Even if one type
1187
is an indefinite type and the other is a subtype of it, <link linkend="FALSE--CAPS"><literal>FALSE</literal></link> will
1188
be returned if they are not exactly equal. If you want to check for
1189
subtypes, use <link linkend="g-variant-type-is-subtype-of"><function>g_variant_type_is_subtype_of()</function></link>.
1192
The argument types of <parameter>type1</parameter> and <parameter>type2</parameter> are only <link linkend="gconstpointer"><type>gconstpointer</type></link> to
1193
allow use with <link linkend="GHashTable"><type>GHashTable</type></link> without function pointer casting. For
1194
both arguments, a valid <link linkend="GVariantType"><type>GVariantType</type></link> must be provided.
1199
</para><variablelist role="params">
1200
<varlistentry><term><parameter>type1</parameter> :</term>
1201
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1202
</simpara></listitem></varlistentry>
1203
<varlistentry><term><parameter>type2</parameter> :</term>
1204
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1205
</simpara></listitem></varlistentry>
1206
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type1</parameter> and <parameter>type2</parameter> are exactly equal
1207
</simpara></listitem></varlistentry>
1208
</variablelist></refsect2>
1209
<refsect2 id="g-variant-type-is-subtype-of" role="function">
1210
<title>g_variant_type_is_subtype_of ()</title>
1211
<indexterm zone="g-variant-type-is-subtype-of"><primary sortas="variant_type_is_subtype_of">g_variant_type_is_subtype_of</primary></indexterm><programlisting><link linkend="gboolean">gboolean</link> g_variant_type_is_subtype_of (const <link linkend="GVariantType">GVariantType</link> *type,
1212
const <link linkend="GVariantType">GVariantType</link> *supertype);</programlisting>
1214
Checks if <parameter>type</parameter> is a subtype of <parameter>supertype</parameter>.
1217
This function returns <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a subtype of <parameter>supertype</parameter>. All
1218
types are considered to be subtypes of themselves. Aside from that,
1219
only indefinite types can have subtypes.
1224
</para><variablelist role="params">
1225
<varlistentry><term><parameter>type</parameter> :</term>
1226
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1227
</simpara></listitem></varlistentry>
1228
<varlistentry><term><parameter>supertype</parameter> :</term>
1229
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1230
</simpara></listitem></varlistentry>
1231
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if <parameter>type</parameter> is a subtype of <parameter>supertype</parameter>
1232
</simpara></listitem></varlistentry>
1233
</variablelist></refsect2>
1234
<refsect2 id="g-variant-type-new-maybe" role="function">
1235
<title>g_variant_type_new_maybe ()</title>
1236
<indexterm zone="g-variant-type-new-maybe"><primary sortas="variant_type_new_maybe">g_variant_type_new_maybe</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_new_maybe (const <link linkend="GVariantType">GVariantType</link> *element);</programlisting>
1238
Constructs the type corresponding to a maybe instance containing
1239
type <parameter>type</parameter> or Nothing.
1242
It is appropriate to call <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on the return value.
1247
</para><variablelist role="params">
1248
<varlistentry><term><parameter>element</parameter> :</term>
1249
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1250
</simpara></listitem></varlistentry>
1251
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new maybe <link linkend="GVariantType"><type>GVariantType</type></link>
1252
</simpara></listitem></varlistentry>
1253
</variablelist></refsect2>
1254
<refsect2 id="g-variant-type-new-array" role="function">
1255
<title>g_variant_type_new_array ()</title>
1256
<indexterm zone="g-variant-type-new-array"><primary sortas="variant_type_new_array">g_variant_type_new_array</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_new_array (const <link linkend="GVariantType">GVariantType</link> *element);</programlisting>
1258
Constructs the type corresponding to an array of elements of the
1259
type <parameter>type</parameter>.
1262
It is appropriate to call <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on the return value.
1267
</para><variablelist role="params">
1268
<varlistentry><term><parameter>element</parameter> :</term>
1269
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1270
</simpara></listitem></varlistentry>
1271
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new array <link linkend="GVariantType"><type>GVariantType</type></link>
1272
</simpara></listitem></varlistentry>
1273
</variablelist></refsect2>
1274
<refsect2 id="g-variant-type-new-tuple" role="function">
1275
<title>g_variant_type_new_tuple ()</title>
1276
<indexterm zone="g-variant-type-new-tuple"><primary sortas="variant_type_new_tuple">g_variant_type_new_tuple</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_new_tuple (const <link linkend="GVariantType">GVariantType</link> * const *items,
1277
<link linkend="gint">gint</link> length);</programlisting>
1279
Constructs a new tuple type, from <parameter>items</parameter>.
1282
<parameter>length</parameter> is the number of items in <parameter>items</parameter>, or -1 to indicate that
1283
<parameter>items</parameter> is <link linkend="NULL--CAPS"><literal>NULL</literal></link>-terminated.
1286
It is appropriate to call <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on the return value.
1291
</para><variablelist role="params">
1292
<varlistentry><term><parameter>items</parameter> :</term>
1293
<listitem><simpara> an array of <link linkend="GVariantTypes"><type>GVariantTypes</type></link>, one for each item
1294
</simpara></listitem></varlistentry>
1295
<varlistentry><term><parameter>length</parameter> :</term>
1296
<listitem><simpara> the length of <parameter>items</parameter>, or -1
1297
</simpara></listitem></varlistentry>
1298
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new tuple <link linkend="GVariantType"><type>GVariantType</type></link>
1299
</simpara></listitem></varlistentry>
1300
</variablelist></refsect2>
1301
<refsect2 id="g-variant-type-new-dict-entry" role="function">
1302
<title>g_variant_type_new_dict_entry ()</title>
1303
<indexterm zone="g-variant-type-new-dict-entry"><primary sortas="variant_type_new_dict_entry">g_variant_type_new_dict_entry</primary></indexterm><programlisting><link linkend="GVariantType">GVariantType</link> * g_variant_type_new_dict_entry (const <link linkend="GVariantType">GVariantType</link> *key,
1304
const <link linkend="GVariantType">GVariantType</link> *value);</programlisting>
1306
Constructs the type corresponding to a dictionary entry with a key
1307
of type <parameter>key</parameter> and a value of type <parameter>value</parameter>.
1310
It is appropriate to call <link linkend="g-variant-type-free"><function>g_variant_type_free()</function></link> on the return value.
1315
</para><variablelist role="params">
1316
<varlistentry><term><parameter>key</parameter> :</term>
1317
<listitem><simpara> a basic <link linkend="GVariantType"><type>GVariantType</type></link>
1318
</simpara></listitem></varlistentry>
1319
<varlistentry><term><parameter>value</parameter> :</term>
1320
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link>
1321
</simpara></listitem></varlistentry>
1322
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a new dictionary entry <link linkend="GVariantType"><type>GVariantType</type></link>
1323
</simpara></listitem></varlistentry>
1324
</variablelist></refsect2>
1325
<refsect2 id="g-variant-type-element" role="function">
1326
<title>g_variant_type_element ()</title>
1327
<indexterm zone="g-variant-type-element"><primary sortas="variant_type_element">g_variant_type_element</primary></indexterm><programlisting>const <link linkend="GVariantType">GVariantType</link> * g_variant_type_element (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1329
Determines the element type of an array or maybe type.
1332
This function may only be used with array or maybe types.
1337
</para><variablelist role="params">
1338
<varlistentry><term><parameter>type</parameter> :</term>
1339
<listitem><simpara> an array or maybe <link linkend="GVariantType"><type>GVariantType</type></link>
1340
</simpara></listitem></varlistentry>
1341
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the element type of <parameter>type</parameter>
1342
</simpara></listitem></varlistentry>
1343
</variablelist></refsect2>
1344
<refsect2 id="g-variant-type-n-items" role="function">
1345
<title>g_variant_type_n_items ()</title>
1346
<indexterm zone="g-variant-type-n-items"><primary sortas="variant_type_n_items">g_variant_type_n_items</primary></indexterm><programlisting><link linkend="gsize">gsize</link> g_variant_type_n_items (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1348
Determines the number of items contained in a tuple or
1349
dictionary entry type.
1352
This function may only be used with tuple or dictionary entry types,
1353
but must not be used with the generic tuple type
1354
<link linkend="G-VARIANT-TYPE-TUPLE--CAPS"><literal>G_VARIANT_TYPE_TUPLE</literal></link>.
1357
In the case of a dictionary entry type, this function will always
1363
</para><variablelist role="params">
1364
<varlistentry><term><parameter>type</parameter> :</term>
1365
<listitem><simpara> a tuple or dictionary entry <link linkend="GVariantType"><type>GVariantType</type></link>
1366
</simpara></listitem></varlistentry>
1367
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the number of items in <parameter>type</parameter>
1368
</simpara></listitem></varlistentry>
1369
</variablelist></refsect2>
1370
<refsect2 id="g-variant-type-first" role="function">
1371
<title>g_variant_type_first ()</title>
1372
<indexterm zone="g-variant-type-first"><primary sortas="variant_type_first">g_variant_type_first</primary></indexterm><programlisting>const <link linkend="GVariantType">GVariantType</link> * g_variant_type_first (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1374
Determines the first item type of a tuple or dictionary entry
1378
This function may only be used with tuple or dictionary entry types,
1379
but must not be used with the generic tuple type
1380
<link linkend="G-VARIANT-TYPE-TUPLE--CAPS"><literal>G_VARIANT_TYPE_TUPLE</literal></link>.
1383
In the case of a dictionary entry type, this returns the type of
1387
<link linkend="NULL--CAPS"><literal>NULL</literal></link> is returned in case of <parameter>type</parameter> being <link linkend="G-VARIANT-TYPE-UNIT--CAPS"><literal>G_VARIANT_TYPE_UNIT</literal></link>.
1390
This call, together with <link linkend="g-variant-type-next"><function>g_variant_type_next()</function></link> provides an iterator
1391
interface over tuple and dictionary entry types.
1396
</para><variablelist role="params">
1397
<varlistentry><term><parameter>type</parameter> :</term>
1398
<listitem><simpara> a tuple or dictionary entry <link linkend="GVariantType"><type>GVariantType</type></link>
1399
</simpara></listitem></varlistentry>
1400
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the first item type of <parameter>type</parameter>, or <link linkend="NULL--CAPS"><literal>NULL</literal></link>
1401
</simpara></listitem></varlistentry>
1402
</variablelist></refsect2>
1403
<refsect2 id="g-variant-type-next" role="function">
1404
<title>g_variant_type_next ()</title>
1405
<indexterm zone="g-variant-type-next"><primary sortas="variant_type_next">g_variant_type_next</primary></indexterm><programlisting>const <link linkend="GVariantType">GVariantType</link> * g_variant_type_next (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1407
Determines the next item type of a tuple or dictionary entry
1411
<parameter>type</parameter> must be the result of a previous call to
1412
<link linkend="g-variant-type-first"><function>g_variant_type_first()</function></link> or <link linkend="g-variant-type-next"><function>g_variant_type_next()</function></link>.
1415
If called on the key type of a dictionary entry then this call
1416
returns the value type. If called on the value type of a dictionary
1417
entry then this call returns <link linkend="NULL--CAPS"><literal>NULL</literal></link>.
1420
For tuples, <link linkend="NULL--CAPS"><literal>NULL</literal></link> is returned when <parameter>type</parameter> is the last item in a tuple.
1425
</para><variablelist role="params">
1426
<varlistentry><term><parameter>type</parameter> :</term>
1427
<listitem><simpara> a <link linkend="GVariantType"><type>GVariantType</type></link> from a previous call
1428
</simpara></listitem></varlistentry>
1429
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the next <link linkend="GVariantType"><type>GVariantType</type></link> after <parameter>type</parameter>, or <link linkend="NULL--CAPS"><literal>NULL</literal></link>
1430
</simpara></listitem></varlistentry>
1431
</variablelist></refsect2>
1432
<refsect2 id="g-variant-type-key" role="function">
1433
<title>g_variant_type_key ()</title>
1434
<indexterm zone="g-variant-type-key"><primary sortas="variant_type_key">g_variant_type_key</primary></indexterm><programlisting>const <link linkend="GVariantType">GVariantType</link> * g_variant_type_key (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1436
Determines the key type of a dictionary entry type.
1439
This function may only be used with a dictionary entry type. Other
1440
than the additional restriction, this call is equivalent to
1441
<link linkend="g-variant-type-first"><function>g_variant_type_first()</function></link>.
1446
</para><variablelist role="params">
1447
<varlistentry><term><parameter>type</parameter> :</term>
1448
<listitem><simpara> a dictionary entry <link linkend="GVariantType"><type>GVariantType</type></link>
1449
</simpara></listitem></varlistentry>
1450
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the key type of the dictionary entry
1451
</simpara></listitem></varlistentry>
1452
</variablelist></refsect2>
1453
<refsect2 id="g-variant-type-value" role="function">
1454
<title>g_variant_type_value ()</title>
1455
<indexterm zone="g-variant-type-value"><primary sortas="variant_type_value">g_variant_type_value</primary></indexterm><programlisting>const <link linkend="GVariantType">GVariantType</link> * g_variant_type_value (const <link linkend="GVariantType">GVariantType</link> *type);</programlisting>
1457
Determines the value type of a dictionary entry type.
1460
This function may only be used with a dictionary entry type.
1465
</para><variablelist role="params">
1466
<varlistentry><term><parameter>type</parameter> :</term>
1467
<listitem><simpara> a dictionary entry <link linkend="GVariantType"><type>GVariantType</type></link>
1468
</simpara></listitem></varlistentry>
1469
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> the value type of the dictionary entry
1470
</simpara></listitem></varlistentry>
1471
</variablelist></refsect2>
1477
<refsect1 id="glib-GVariantType.see-also">
1478
<title>See Also</title>
1479
#GVariantType, <link linkend="GVariant"><type>GVariant</type></link>
added
removed
docs/reference/glib/xml/gvarianttype.xml
