docs/reference/glib/html/glib-GVariantType.html

   1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <html>
   3 <head>
   4 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   5 <title>GVariantType</title>
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
   7 <link rel="home" href="index.html" title="GLib Reference Manual">
   8 <link rel="up" href="glib-data-types.html" title="GLib Data Types">
   9 <link rel="prev" href="glib-Datasets.html" title="Datasets">
  10 <link rel="next" href="glib-GVariant.html" title="GVariant">
  11 <meta name="generator" content="GTK-Doc V1.18 (XML mode)">
  12 <link rel="stylesheet" href="style.css" type="text/css">
  13 </head>
  14 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  15 <table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2">
  16 <tr valign="middle">
  17 <td><a accesskey="p" href="glib-Datasets.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
  18 <td><a accesskey="u" href="glib-data-types.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
  19 <td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
  20 <th width="100%" align="center">GLib Reference Manual</th>
  21 <td><a accesskey="n" href="glib-GVariant.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
  22 </tr>
  23 <tr><td colspan="5" class="shortcuts">
  24 <a href="#glib-GVariantType.synopsis" class="shortcut">Top</a>
  25                    |
  26                   <a href="#glib-GVariantType.description" class="shortcut">Description</a>
  27 </td></tr>
  28 </table>
  29 <div class="refentry">
  30 <a name="glib-GVariantType"></a><div class="titlepage"></div>
  31 <div class="refnamediv"><table width="100%"><tr>
  32 <td valign="top">
  33 <h2><span class="refentrytitle"><a name="glib-GVariantType.top_of_page"></a>GVariantType</span></h2>
  34 <p>GVariantType — introduction to the GVariant type system</p>
  35 </td>
  36 <td valign="top" align="right"></td>
  37 </tr></table></div>
  38 <div class="refsynopsisdiv">
  39 <a name="glib-GVariantType.synopsis"></a><h2>Synopsis</h2>
  40 <pre class="synopsis">
  41 #include &lt;glib.h&gt;
  42
  43                     <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType">GVariantType</a>;
  44 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BOOLEAN:CAPS" title="G_VARIANT_TYPE_BOOLEAN">G_VARIANT_TYPE_BOOLEAN</a>
  45 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTE:CAPS" title="G_VARIANT_TYPE_BYTE">G_VARIANT_TYPE_BYTE</a>
  46 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT16:CAPS" title="G_VARIANT_TYPE_INT16">G_VARIANT_TYPE_INT16</a>
  47 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT16:CAPS" title="G_VARIANT_TYPE_UINT16">G_VARIANT_TYPE_UINT16</a>
  48 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT32:CAPS" title="G_VARIANT_TYPE_INT32">G_VARIANT_TYPE_INT32</a>
  49 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT32:CAPS" title="G_VARIANT_TYPE_UINT32">G_VARIANT_TYPE_UINT32</a>
  50 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT64:CAPS" title="G_VARIANT_TYPE_INT64">G_VARIANT_TYPE_INT64</a>
  51 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT64:CAPS" title="G_VARIANT_TYPE_UINT64">G_VARIANT_TYPE_UINT64</a>
  52 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-HANDLE:CAPS" title="G_VARIANT_TYPE_HANDLE">G_VARIANT_TYPE_HANDLE</a>
  53 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DOUBLE:CAPS" title="G_VARIANT_TYPE_DOUBLE">G_VARIANT_TYPE_DOUBLE</a>
  54 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING">G_VARIANT_TYPE_STRING</a>
  55 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-OBJECT-PATH:CAPS" title="G_VARIANT_TYPE_OBJECT_PATH">G_VARIANT_TYPE_OBJECT_PATH</a>
  56 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-SIGNATURE:CAPS" title="G_VARIANT_TYPE_SIGNATURE">G_VARIANT_TYPE_SIGNATURE</a>
  57 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-VARIANT:CAPS" title="G_VARIANT_TYPE_VARIANT">G_VARIANT_TYPE_VARIANT</a>
  58 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ANY:CAPS" title="G_VARIANT_TYPE_ANY">G_VARIANT_TYPE_ANY</a>
  59 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC">G_VARIANT_TYPE_BASIC</a>
  60 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-MAYBE:CAPS" title="G_VARIANT_TYPE_MAYBE">G_VARIANT_TYPE_MAYBE</a>
  61 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY">G_VARIANT_TYPE_ARRAY</a>
  62 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE">G_VARIANT_TYPE_TUPLE</a>
  63 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UNIT:CAPS" title="G_VARIANT_TYPE_UNIT">G_VARIANT_TYPE_UNIT</a>
  64 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICT-ENTRY:CAPS" title="G_VARIANT_TYPE_DICT_ENTRY">G_VARIANT_TYPE_DICT_ENTRY</a>
  65 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICTIONARY:CAPS" title="G_VARIANT_TYPE_DICTIONARY">G_VARIANT_TYPE_DICTIONARY</a>
  66 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING-ARRAY:CAPS" title="G_VARIANT_TYPE_STRING_ARRAY">G_VARIANT_TYPE_STRING_ARRAY</a>
  67 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-OBJECT-PATH-ARRAY:CAPS" title="G_VARIANT_TYPE_OBJECT_PATH_ARRAY">G_VARIANT_TYPE_OBJECT_PATH_ARRAY</a>
  68 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTESTRING:CAPS" title="G_VARIANT_TYPE_BYTESTRING">G_VARIANT_TYPE_BYTESTRING</a>
  69 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTESTRING-ARRAY:CAPS" title="G_VARIANT_TYPE_BYTESTRING_ARRAY">G_VARIANT_TYPE_BYTESTRING_ARRAY</a>
  70 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-VARDICT:CAPS" title="G_VARIANT_TYPE_VARDICT">G_VARIANT_TYPE_VARDICT</a>
  71
  72 #define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE:CAPS" title="G_VARIANT_TYPE()">G_VARIANT_TYPE</a>                      (type_string)
  73 <span class="returnvalue">void</span>                <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()">g_variant_type_free</a>                 (<em class="parameter"><code><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  74 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()">g_variant_type_copy</a>                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  75 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new" title="g_variant_type_new ()">g_variant_type_new</a>                  (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);
  76
  77 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()">g_variant_type_string_is_valid</a>      (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);
  78 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-string-scan" title="g_variant_type_string_scan ()">g_variant_type_string_scan</a>          (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *string</code></em>,
  79                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *limit</code></em>,
  80                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> **endptr</code></em>);
  81 <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-get-string-length" title="g_variant_type_get_string_length ()">g_variant_type_get_string_length</a>    (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  82 const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *       <a class="link" href="glib-GVariantType.html#g-variant-type-peek-string" title="g_variant_type_peek_string ()">g_variant_type_peek_string</a>          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  83 <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *             <a class="link" href="glib-GVariantType.html#g-variant-type-dup-string" title="g_variant_type_dup_string ()">g_variant_type_dup_string</a>           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  84
  85 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-definite" title="g_variant_type_is_definite ()">g_variant_type_is_definite</a>          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  86 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-container" title="g_variant_type_is_container ()">g_variant_type_is_container</a>         (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  87 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-basic" title="g_variant_type_is_basic ()">g_variant_type_is_basic</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  88 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-maybe" title="g_variant_type_is_maybe ()">g_variant_type_is_maybe</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  89 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-array" title="g_variant_type_is_array ()">g_variant_type_is_array</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  90 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-tuple" title="g_variant_type_is_tuple ()">g_variant_type_is_tuple</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  91 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-dict-entry" title="g_variant_type_is_dict_entry ()">g_variant_type_is_dict_entry</a>        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  92 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-variant" title="g_variant_type_is_variant ()">g_variant_type_is_variant</a>           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
  93
  94 <a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-hash" title="g_variant_type_hash ()">g_variant_type_hash</a>                 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type</code></em>);
  95 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-equal" title="g_variant_type_equal ()">g_variant_type_equal</a>                (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type1</code></em>,
  96                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type2</code></em>);
  97 <a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-subtype-of" title="g_variant_type_is_subtype_of ()">g_variant_type_is_subtype_of</a>        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>,
  98                                                          <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *supertype</code></em>);
  99
 100 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-maybe" title="g_variant_type_new_maybe ()">g_variant_type_new_maybe</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);
 101 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-array" title="g_variant_type_new_array ()">g_variant_type_new_array</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);
 102 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-tuple" title="g_variant_type_new_tuple ()">g_variant_type_new_tuple</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> * const *items</code></em>,
 103                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="type">gint</span></a> length</code></em>);
 104 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-dict-entry" title="g_variant_type_new_dict_entry ()">g_variant_type_new_dict_entry</a>       (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *key</code></em>,
 105                                                          <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *value</code></em>);
 106
 107 const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-element" title="g_variant_type_element ()">g_variant_type_element</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 108 <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-n-items" title="g_variant_type_n_items ()">g_variant_type_n_items</a>              (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 109 const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()">g_variant_type_first</a>               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 110 const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()">g_variant_type_next</a>                (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 111 const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-key" title="g_variant_type_key ()">g_variant_type_key</a>                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 112 const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-value" title="g_variant_type_value ()">g_variant_type_value</a>               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
 113 </pre>
 114 </div>
 115 <div class="refsect1">
 116 <a name="glib-GVariantType.description"></a><h2>Description</h2>
 117 <p>
 118 This section introduces the GVariant type system.  It is based, in
 119 large part, on the D-Bus type system, with two major changes and some minor
 120 lifting of restrictions.  The <a class="ulink" href="http://dbus.freedesktop.org/doc/dbus-specification.html" target="_top">DBus
 121 specification</a>, therefore, provides a significant amount of
 122 information that is useful when working with GVariant.
 123 </p>
 124 <p>
 125 The first major change with respect to the D-Bus type system is the
 126 introduction of maybe (or "nullable") types.  Any type in GVariant can be
 127 converted to a maybe type, in which case, "nothing" (or "null") becomes a
 128 valid value.  Maybe types have been added by introducing the
 129 character "<code class="literal">m</code>" to type strings.
 130 </p>
 131 <p>
 132 The second major change is that the GVariant type system supports the
 133 concept of "indefinite types" -- types that are less specific than
 134 the normal types found in D-Bus.  For example, it is possible to speak
 135 of "an array of any type" in GVariant, where the D-Bus type system
 136 would require you to speak of "an array of integers" or "an array of
 137 strings".  Indefinite types have been added by introducing the
 138 characters "<code class="literal">*</code>", "<code class="literal">?</code>" and
 139 "<code class="literal">r</code>" to type strings.
 140 </p>
 141 <p>
 142 Finally, all arbitrary restrictions relating to the complexity of
 143 types are lifted along with the restriction that dictionary entries
 144 may only appear nested inside of arrays.
 145 </p>
 146 <p>
 147 Just as in D-Bus, GVariant types are described with strings ("type
 148 strings").  Subject to the differences mentioned above, these strings
 149 are of the same form as those found in DBus.  Note, however: D-Bus
 150 always works in terms of messages and therefore individual type
 151 strings appear nowhere in its interface.  Instead, "signatures"
 152 are a concatenation of the strings of the type of each argument in a
 153 message.  GVariant deals with single values directly so GVariant type
 154 strings always describe the type of exactly one value.  This means
 155 that a D-Bus signature string is generally not a valid GVariant type
 156 string -- except in the case that it is the signature of a message
 157 containing exactly one argument.
 158 </p>
 159 <p>
 160 An indefinite type is similar in spirit to what may be called an
 161 abstract type in other type systems.  No value can exist that has an
 162 indefinite type as its type, but values can exist that have types
 163 that are subtypes of indefinite types.  That is to say,
 164 <a class="link" href="glib-GVariant.html#g-variant-get-type" title="g_variant_get_type ()"><code class="function">g_variant_get_type()</code></a> will never return an indefinite type, but
 165 calling <a class="link" href="glib-GVariant.html#g-variant-is-of-type" title="g_variant_is_of_type ()"><code class="function">g_variant_is_of_type()</code></a> with an indefinite type may return
 166 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>.  For example, you cannot have a value that represents "an
 167 array of no particular type", but you can have an "array of integers"
 168 which certainly matches the type of "an array of no particular type",
 169 since "array of integers" is a subtype of "array of no particular
 170 type".
 171 </p>
 172 <p>
 173 This is similar to how instances of abstract classes may not
 174 directly exist in other type systems, but instances of their
 175 non-abstract subtypes may.  For example, in GTK, no object that has
 176 the type of <a href="http://library.gnome.org/devel/gtk/GtkBin.html"><span class="type">GtkBin</span></a> can exist (since <a href="http://library.gnome.org/devel/gtk/GtkBin.html"><span class="type">GtkBin</span></a> is an abstract class),
 177 but a <a href="http://library.gnome.org/devel/gtk/GtkWindow.html"><span class="type">GtkWindow</span></a> can certainly be instantiated, and you would say
 178 that the <a href="http://library.gnome.org/devel/gtk/GtkWindow.html"><span class="type">GtkWindow</span></a> is a <a href="http://library.gnome.org/devel/gtk/GtkBin.html"><span class="type">GtkBin</span></a> (since <a href="http://library.gnome.org/devel/gtk/GtkWindow.html"><span class="type">GtkWindow</span></a> is a subclass of
 179 <a href="http://library.gnome.org/devel/gtk/GtkBin.html"><span class="type">GtkBin</span></a>).
 180 </p>
 181 <p>
 182 A detailed description of GVariant type strings is given here:
 183 </p>
 184 <p>
 185 </p>
 186 <div class="refsect2">
 187 <a name="gvariant-typestrings"></a><h3>GVariant Type Strings</h3>
 188 <p>
 189   A GVariant type string can be any of the following:
 190  </p>
 191 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 192 <li class="listitem"><p>
 193     any basic type string (listed below)
 194    </p></li>
 195 <li class="listitem"><p>
 196     "<code class="literal">v</code>", "<code class="literal">r</code>" or
 197     "<code class="literal">*</code>"
 198    </p></li>
 199 <li class="listitem"><p>
 200     one of the characters '<code class="literal">a</code>' or
 201     '<code class="literal">m</code>', followed by another type string
 202    </p></li>
 203 <li class="listitem"><p>
 204     the character '<code class="literal">(</code>', followed by a concatenation
 205     of zero or more other type strings, followed by the character
 206     '<code class="literal">)</code>'
 207    </p></li>
 208 <li class="listitem"><p>
 209     the character '<code class="literal">{</code>', followed by a basic type
 210     string (see below), followed by another type string, followed by
 211     the character '<code class="literal">}</code>'
 212    </p></li>
 213 </ul></div>
 214 <p>
 215   A basic type string describes a basic type (as per
 216   <a class="link" href="glib-GVariantType.html#g-variant-type-is-basic" title="g_variant_type_is_basic ()"><code class="function">g_variant_type_is_basic()</code></a>) and is always a single
 217   character in length.  The valid basic type strings are
 218   "<code class="literal">b</code>", "<code class="literal">y</code>",
 219   "<code class="literal">n</code>", "<code class="literal">q</code>",
 220   "<code class="literal">i</code>", "<code class="literal">u</code>",
 221   "<code class="literal">x</code>", "<code class="literal">t</code>",
 222   "<code class="literal">h</code>", "<code class="literal">d</code>",
 223   "<code class="literal">s</code>", "<code class="literal">o</code>",
 224   "<code class="literal">g</code>" and "<code class="literal">?</code>".
 225  </p>
 226 <p>
 227   The above definition is recursive to arbitrary depth.
 228   "<code class="literal">aaaaai</code>" and "<code class="literal">(ui(nq((y)))s)</code>"
 229   are both valid type strings, as is
 230   "<code class="literal">a(aa(ui)(qna{ya(yd)}))</code>".
 231  </p>
 232 <p>
 233   The meaning of each of the characters is as follows:
 234  </p>
 235 <div class="informaltable"><table border="1">
 236 <colgroup>
 237 <col>
 238 <col>
 239 </colgroup>
 240 <tbody>
 241 <tr>
 242 <td>
 243       <p>
 244        <span class="strong"><strong>Character</strong></span>
 245       </p>
 246      </td>
 247 <td>
 248       <p>
 249        <span class="strong"><strong>Meaning</strong></span>
 250       </p>
 251      </td>
 252 </tr>
 253 <tr>
 254 <td>
 255       <p>
 256        <code class="literal">b</code>
 257       </p>
 258      </td>
 259 <td>
 260       <p>
 261        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BOOLEAN:CAPS" title="G_VARIANT_TYPE_BOOLEAN"><code class="literal">G_VARIANT_TYPE_BOOLEAN</code></a>; a boolean value.
 262       </p>
 263      </td>
 264 </tr>
 265 <tr>
 266 <td>
 267       <p>
 268        <code class="literal">y</code>
 269       </p>
 270      </td>
 271 <td>
 272       <p>
 273        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTE:CAPS" title="G_VARIANT_TYPE_BYTE"><code class="literal">G_VARIANT_TYPE_BYTE</code></a>; a byte.
 274       </p>
 275      </td>
 276 </tr>
 277 <tr>
 278 <td>
 279       <p>
 280        <code class="literal">n</code>
 281       </p>
 282      </td>
 283 <td>
 284       <p>
 285        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT16:CAPS" title="G_VARIANT_TYPE_INT16"><code class="literal">G_VARIANT_TYPE_INT16</code></a>; a signed 16 bit
 286        integer.
 287       </p>
 288      </td>
 289 </tr>
 290 <tr>
 291 <td>
 292       <p>
 293        <code class="literal">q</code>
 294       </p>
 295      </td>
 296 <td>
 297       <p>
 298        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT16:CAPS" title="G_VARIANT_TYPE_UINT16"><code class="literal">G_VARIANT_TYPE_UINT16</code></a>; an unsigned 16 bit
 299        integer.
 300       </p>
 301      </td>
 302 </tr>
 303 <tr>
 304 <td>
 305       <p>
 306        <code class="literal">i</code>
 307       </p>
 308      </td>
 309 <td>
 310       <p>
 311        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT32:CAPS" title="G_VARIANT_TYPE_INT32"><code class="literal">G_VARIANT_TYPE_INT32</code></a>; a signed 32 bit
 312        integer.
 313       </p>
 314      </td>
 315 </tr>
 316 <tr>
 317 <td>
 318       <p>
 319        <code class="literal">u</code>
 320       </p>
 321      </td>
 322 <td>
 323       <p>
 324        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT32:CAPS" title="G_VARIANT_TYPE_UINT32"><code class="literal">G_VARIANT_TYPE_UINT32</code></a>; an unsigned 32 bit
 325        integer.
 326       </p>
 327      </td>
 328 </tr>
 329 <tr>
 330 <td>
 331       <p>
 332        <code class="literal">x</code>
 333       </p>
 334      </td>
 335 <td>
 336       <p>
 337        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT64:CAPS" title="G_VARIANT_TYPE_INT64"><code class="literal">G_VARIANT_TYPE_INT64</code></a>; a signed 64 bit
 338        integer.
 339       </p>
 340      </td>
 341 </tr>
 342 <tr>
 343 <td>
 344       <p>
 345        <code class="literal">t</code>
 346       </p>
 347      </td>
 348 <td>
 349       <p>
 350        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT64:CAPS" title="G_VARIANT_TYPE_UINT64"><code class="literal">G_VARIANT_TYPE_UINT64</code></a>; an unsigned 64 bit
 351        integer.
 352       </p>
 353      </td>
 354 </tr>
 355 <tr>
 356 <td>
 357       <p>
 358        <code class="literal">h</code>
 359       </p>
 360      </td>
 361 <td>
 362       <p>
 363        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-HANDLE:CAPS" title="G_VARIANT_TYPE_HANDLE"><code class="literal">G_VARIANT_TYPE_HANDLE</code></a>; a signed 32 bit
 364        value that, by convention, is used as an index into an array
 365        of file descriptors that are sent alongside a D-Bus message.
 366       </p>
 367      </td>
 368 </tr>
 369 <tr>
 370 <td>
 371       <p>
 372        <code class="literal">d</code>
 373       </p>
 374      </td>
 375 <td>
 376       <p>
 377        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DOUBLE:CAPS" title="G_VARIANT_TYPE_DOUBLE"><code class="literal">G_VARIANT_TYPE_DOUBLE</code></a>; a double precision
 378        floating point value.
 379       </p>
 380      </td>
 381 </tr>
 382 <tr>
 383 <td>
 384       <p>
 385        <code class="literal">s</code>
 386       </p>
 387      </td>
 388 <td>
 389       <p>
 390        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING"><code class="literal">G_VARIANT_TYPE_STRING</code></a>; a string.
 391       </p>
 392      </td>
 393 </tr>
 394 <tr>
 395 <td>
 396       <p>
 397        <code class="literal">o</code>
 398       </p>
 399      </td>
 400 <td>
 401       <p>
 402        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-OBJECT-PATH:CAPS" title="G_VARIANT_TYPE_OBJECT_PATH"><code class="literal">G_VARIANT_TYPE_OBJECT_PATH</code></a>; a string in
 403        the form of a D-Bus object path.
 404       </p>
 405      </td>
 406 </tr>
 407 <tr>
 408 <td>
 409       <p>
 410        <code class="literal">g</code>
 411       </p>
 412      </td>
 413 <td>
 414       <p>
 415        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING"><code class="literal">G_VARIANT_TYPE_STRING</code></a>; a string in the
 416        form of a D-Bus type signature.
 417       </p>
 418      </td>
 419 </tr>
 420 <tr>
 421 <td>
 422       <p>
 423        <code class="literal">?</code>
 424       </p>
 425      </td>
 426 <td>
 427       <p>
 428        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC"><code class="literal">G_VARIANT_TYPE_BASIC</code></a>; an indefinite type
 429        that is a supertype of any of the basic types.
 430       </p>
 431      </td>
 432 </tr>
 433 <tr>
 434 <td>
 435       <p>
 436        <code class="literal">v</code>
 437       </p>
 438      </td>
 439 <td>
 440       <p>
 441        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-VARIANT:CAPS" title="G_VARIANT_TYPE_VARIANT"><code class="literal">G_VARIANT_TYPE_VARIANT</code></a>; a container type
 442        that contain any other type of value.
 443       </p>
 444      </td>
 445 </tr>
 446 <tr>
 447 <td>
 448       <p>
 449        <code class="literal">a</code>
 450       </p>
 451      </td>
 452 <td>
 453       <p>
 454        used as a prefix on another type string to mean an array of
 455        that type; the type string "<code class="literal">ai</code>", for
 456        example, is the type of an array of 32 bit signed integers.
 457       </p>
 458      </td>
 459 </tr>
 460 <tr>
 461 <td>
 462       <p>
 463        <code class="literal">m</code>
 464       </p>
 465      </td>
 466 <td>
 467       <p>
 468        used as a prefix on another type string to mean a "maybe", or
 469        "nullable", version of that type; the type string
 470        "<code class="literal">ms</code>", for example, is the type of a value
 471        that maybe contains a string, or maybe contains nothing.
 472       </p>
 473      </td>
 474 </tr>
 475 <tr>
 476 <td>
 477       <p>
 478        <code class="literal">()</code>
 479       </p>
 480      </td>
 481 <td>
 482       <p>
 483        used to enclose zero or more other concatenated type strings
 484        to create a tuple type; the type string
 485        "<code class="literal">(is)</code>", for example, is the type of a pair
 486        of an integer and a string.
 487       </p>
 488      </td>
 489 </tr>
 490 <tr>
 491 <td>
 492       <p>
 493        <code class="literal">r</code>
 494       </p>
 495      </td>
 496 <td>
 497       <p>
 498        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>; an indefinite type
 499        that is a supertype of any tuple type, regardless of the
 500        number of items.
 501       </p>
 502      </td>
 503 </tr>
 504 <tr>
 505 <td>
 506       <p>
 507        <code class="literal">{}</code>
 508       </p>
 509      </td>
 510 <td>
 511       <p>
 512        used to enclose a basic type string concatenated with another
 513        type string to create a dictionary entry type, which usually
 514        appears inside of an array to form a dictionary; the type
 515        string "<code class="literal">a{sd}</code>", for example, is the type of
 516        a dictionary that maps strings to double precision floating
 517        point values.
 518       </p>
 519       <p>
 520        The first type (the basic type) is the key type and the second
 521        type is the value type.  The reason that the first type is
 522        restricted to being a basic type is so that it can easily be
 523        hashed.
 524       </p>
 525      </td>
 526 </tr>
 527 <tr>
 528 <td>
 529       <p>
 530        <code class="literal">*</code>
 531       </p>
 532      </td>
 533 <td>
 534       <p>
 535        the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ANY:CAPS" title="G_VARIANT_TYPE_ANY"><code class="literal">G_VARIANT_TYPE_ANY</code></a>; the indefinite type
 536        that is a supertype of all types.  Note that, as with all type
 537        strings, this character represents exactly one type.  It
 538        cannot be used inside of tuples to mean "any number of items".
 539       </p>
 540      </td>
 541 </tr>
 542 </tbody>
 543 </table></div>
 544 <p>
 545   Any type string of a container that contains an indefinite type is,
 546   itself, an indefinite type.  For example, the type string
 547   "<code class="literal">a*</code>" (corresponding to <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>) is
 548   an indefinite type that is a supertype of every array type.
 549   "<code class="literal">(*s)</code>" is a supertype of all tuples that
 550   contain exactly two items where the second item is a string.
 551  </p>
 552 <p>
 553   "<code class="literal">a{?*}</code>" is an indefinite type that is a
 554   supertype of all arrays containing dictionary entries where the key
 555   is any basic type and the value is any type at all.  This is, by
 556   definition, a dictionary, so this type string corresponds to
 557   <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICTIONARY:CAPS" title="G_VARIANT_TYPE_DICTIONARY"><code class="literal">G_VARIANT_TYPE_DICTIONARY</code></a>.  Note that, due to the restriction that
 558   the key of a dictionary entry must be a basic type,
 559   "<code class="literal">{**}</code>" is not a valid type string.
 560  </p>
 561 </div>
 562 <p>
 563 </p>
 564 </div>
 565 <div class="refsect1">
 566 <a name="glib-GVariantType.details"></a><h2>Details</h2>
 567 <div class="refsect2">
 568 <a name="GVariantType"></a><h3>GVariantType</h3>
 569 <pre class="programlisting">typedef struct _GVariantType GVariantType;</pre>
 570 <p>
 571 A type in the GVariant type system.
 572 </p>
 573 <p>
 574 Two types may not be compared by value; use <a class="link" href="glib-GVariantType.html#g-variant-type-equal" title="g_variant_type_equal ()"><code class="function">g_variant_type_equal()</code></a> or
 575 <a class="link" href="glib-GVariantType.html#g-variant-type-is-subtype-of" title="g_variant_type_is_subtype_of ()"><code class="function">g_variant_type_is_subtype_of()</code></a>.  May be copied using
 576 <a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()"><code class="function">g_variant_type_copy()</code></a> and freed using <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a>.
 577 </p>
 578 </div>
 579 <hr>
 580 <div class="refsect2">
 581 <a name="G-VARIANT-TYPE-BOOLEAN:CAPS"></a><h3>G_VARIANT_TYPE_BOOLEAN</h3>
 582 <pre class="programlisting">#define G_VARIANT_TYPE_BOOLEAN              ((const GVariantType *) "b")
 583 </pre>
 584 <p>
 585 The type of a value that can be either <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> or <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a>.
 586 </p>
 587 </div>
 588 <hr>
 589 <div class="refsect2">
 590 <a name="G-VARIANT-TYPE-BYTE:CAPS"></a><h3>G_VARIANT_TYPE_BYTE</h3>
 591 <pre class="programlisting">#define G_VARIANT_TYPE_BYTE                 ((const GVariantType *) "y")
 592 </pre>
 593 <p>
 594 The type of an integer value that can range from 0 to 255.
 595 </p>
 596 </div>
 597 <hr>
 598 <div class="refsect2">
 599 <a name="G-VARIANT-TYPE-INT16:CAPS"></a><h3>G_VARIANT_TYPE_INT16</h3>
 600 <pre class="programlisting">#define G_VARIANT_TYPE_INT16                ((const GVariantType *) "n")
 601 </pre>
 602 <p>
 603 The type of an integer value that can range from -32768 to 32767.
 604 </p>
 605 </div>
 606 <hr>
 607 <div class="refsect2">
 608 <a name="G-VARIANT-TYPE-UINT16:CAPS"></a><h3>G_VARIANT_TYPE_UINT16</h3>
 609 <pre class="programlisting">#define G_VARIANT_TYPE_UINT16               ((const GVariantType *) "q")
 610 </pre>
 611 <p>
 612 The type of an integer value that can range from 0 to 65535.
 613 There were about this many people living in Toronto in the 1870s.
 614 </p>
 615 </div>
 616 <hr>
 617 <div class="refsect2">
 618 <a name="G-VARIANT-TYPE-INT32:CAPS"></a><h3>G_VARIANT_TYPE_INT32</h3>
 619 <pre class="programlisting">#define G_VARIANT_TYPE_INT32                ((const GVariantType *) "i")
 620 </pre>
 621 <p>
 622 The type of an integer value that can range from -2147483648 to
 623 2147483647.
 624 </p>
 625 </div>
 626 <hr>
 627 <div class="refsect2">
 628 <a name="G-VARIANT-TYPE-UINT32:CAPS"></a><h3>G_VARIANT_TYPE_UINT32</h3>
 629 <pre class="programlisting">#define G_VARIANT_TYPE_UINT32               ((const GVariantType *) "u")
 630 </pre>
 631 <p>
 632 The type of an integer value that can range from 0 to 4294967295.
 633 That's one number for everyone who was around in the late 1970s.
 634 </p>
 635 </div>
 636 <hr>
 637 <div class="refsect2">
 638 <a name="G-VARIANT-TYPE-INT64:CAPS"></a><h3>G_VARIANT_TYPE_INT64</h3>
 639 <pre class="programlisting">#define G_VARIANT_TYPE_INT64                ((const GVariantType *) "x")
 640 </pre>
 641 <p>
 642 The type of an integer value that can range from
 643 -9223372036854775808 to 9223372036854775807.
 644 </p>
 645 </div>
 646 <hr>
 647 <div class="refsect2">
 648 <a name="G-VARIANT-TYPE-UINT64:CAPS"></a><h3>G_VARIANT_TYPE_UINT64</h3>
 649 <pre class="programlisting">#define G_VARIANT_TYPE_UINT64               ((const GVariantType *) "t")
 650 </pre>
 651 <p>
 652 The type of an integer value that can range from 0 to
 653 18446744073709551616.  That's a really big number, but a Rubik's
 654 cube can have a bit more than twice as many possible positions.
 655 </p>
 656 </div>
 657 <hr>
 658 <div class="refsect2">
 659 <a name="G-VARIANT-TYPE-HANDLE:CAPS"></a><h3>G_VARIANT_TYPE_HANDLE</h3>
 660 <pre class="programlisting">#define G_VARIANT_TYPE_HANDLE               ((const GVariantType *) "h")
 661 </pre>
 662 <p>
 663 The type of a 32bit signed integer value, that by convention, is used
 664 as an index into an array of file descriptors that are sent alongside
 665 a D-Bus message.
 666 </p>
 667 <p>
 668 If you are not interacting with D-Bus, then there is no reason to make
 669 use of this type.
 670 </p>
 671 </div>
 672 <hr>
 673 <div class="refsect2">
 674 <a name="G-VARIANT-TYPE-DOUBLE:CAPS"></a><h3>G_VARIANT_TYPE_DOUBLE</h3>
 675 <pre class="programlisting">#define G_VARIANT_TYPE_DOUBLE               ((const GVariantType *) "d")
 676 </pre>
 677 <p>
 678 The type of a double precision IEEE754 floating point number.
 679 These guys go up to about 1.80e308 (plus and minus) but miss out on
 680 some numbers in between.  In any case, that's far greater than the
 681 estimated number of fundamental particles in the observable
 682 universe.
 683 </p>
 684 </div>
 685 <hr>
 686 <div class="refsect2">
 687 <a name="G-VARIANT-TYPE-STRING:CAPS"></a><h3>G_VARIANT_TYPE_STRING</h3>
 688 <pre class="programlisting">#define G_VARIANT_TYPE_STRING               ((const GVariantType *) "s")
 689 </pre>
 690 <p>
 691 The type of a string.  "" is a string.  <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is not a string.
 692 </p>
 693 </div>
 694 <hr>
 695 <div class="refsect2">
 696 <a name="G-VARIANT-TYPE-OBJECT-PATH:CAPS"></a><h3>G_VARIANT_TYPE_OBJECT_PATH</h3>
 697 <pre class="programlisting">#define G_VARIANT_TYPE_OBJECT_PATH          ((const GVariantType *) "o")
 698 </pre>
 699 <p>
 700 The type of a D-Bus object reference.  These are strings of a
 701 specific format used to identify objects at a given destination on
 702 the bus.
 703 </p>
 704 <p>
 705 If you are not interacting with D-Bus, then there is no reason to make
 706 use of this type.  If you are, then the D-Bus specification contains a
 707 precise description of valid object paths.
 708 </p>
 709 </div>
 710 <hr>
 711 <div class="refsect2">
 712 <a name="G-VARIANT-TYPE-SIGNATURE:CAPS"></a><h3>G_VARIANT_TYPE_SIGNATURE</h3>
 713 <pre class="programlisting">#define G_VARIANT_TYPE_SIGNATURE            ((const GVariantType *) "g")
 714 </pre>
 715 <p>
 716 The type of a D-Bus type signature.  These are strings of a specific
 717 format used as type signatures for D-Bus methods and messages.
 718 </p>
 719 <p>
 720 If you are not interacting with D-Bus, then there is no reason to make
 721 use of this type.  If you are, then the D-Bus specification contains a
 722 precise description of valid signature strings.
 723 </p>
 724 </div>
 725 <hr>
 726 <div class="refsect2">
 727 <a name="G-VARIANT-TYPE-VARIANT:CAPS"></a><h3>G_VARIANT_TYPE_VARIANT</h3>
 728 <pre class="programlisting">#define G_VARIANT_TYPE_VARIANT              ((const GVariantType *) "v")
 729 </pre>
 730 <p>
 731 The type of a box that contains any other value (including another
 732 variant).
 733 </p>
 734 </div>
 735 <hr>
 736 <div class="refsect2">
 737 <a name="G-VARIANT-TYPE-ANY:CAPS"></a><h3>G_VARIANT_TYPE_ANY</h3>
 738 <pre class="programlisting">#define G_VARIANT_TYPE_ANY                  ((const GVariantType *) "*")
 739 </pre>
 740 <p>
 741 An indefinite type that is a supertype of every type (including
 742 itself).
 743 </p>
 744 </div>
 745 <hr>
 746 <div class="refsect2">
 747 <a name="G-VARIANT-TYPE-BASIC:CAPS"></a><h3>G_VARIANT_TYPE_BASIC</h3>
 748 <pre class="programlisting">#define G_VARIANT_TYPE_BASIC                ((const GVariantType *) "?")
 749 </pre>
 750 <p>
 751 An indefinite type that is a supertype of every basic (ie:
 752 non-container) type.
 753 </p>
 754 </div>
 755 <hr>
 756 <div class="refsect2">
 757 <a name="G-VARIANT-TYPE-MAYBE:CAPS"></a><h3>G_VARIANT_TYPE_MAYBE</h3>
 758 <pre class="programlisting">#define G_VARIANT_TYPE_MAYBE                ((const GVariantType *) "m*")
 759 </pre>
 760 <p>
 761 An indefinite type that is a supertype of every maybe type.
 762 </p>
 763 </div>
 764 <hr>
 765 <div class="refsect2">
 766 <a name="G-VARIANT-TYPE-ARRAY:CAPS"></a><h3>G_VARIANT_TYPE_ARRAY</h3>
 767 <pre class="programlisting">#define G_VARIANT_TYPE_ARRAY                ((const GVariantType *) "a*")
 768 </pre>
 769 <p>
 770 An indefinite type that is a supertype of every array type.
 771 </p>
 772 </div>
 773 <hr>
 774 <div class="refsect2">
 775 <a name="G-VARIANT-TYPE-TUPLE:CAPS"></a><h3>G_VARIANT_TYPE_TUPLE</h3>
 776 <pre class="programlisting">#define G_VARIANT_TYPE_TUPLE                ((const GVariantType *) "r")
 777 </pre>
 778 <p>
 779 An indefinite type that is a supertype of every tuple type,
 780 regardless of the number of items in the tuple.
 781 </p>
 782 </div>
 783 <hr>
 784 <div class="refsect2">
 785 <a name="G-VARIANT-TYPE-UNIT:CAPS"></a><h3>G_VARIANT_TYPE_UNIT</h3>
 786 <pre class="programlisting">#define G_VARIANT_TYPE_UNIT                 ((const GVariantType *) "()")
 787 </pre>
 788 <p>
 789 The empty tuple type.  Has only one instance.  Known also as "triv"
 790 or "void".
 791 </p>
 792 </div>
 793 <hr>
 794 <div class="refsect2">
 795 <a name="G-VARIANT-TYPE-DICT-ENTRY:CAPS"></a><h3>G_VARIANT_TYPE_DICT_ENTRY</h3>
 796 <pre class="programlisting">#define G_VARIANT_TYPE_DICT_ENTRY           ((const GVariantType *) "{?*}")
 797 </pre>
 798 <p>
 799 An indefinite type that is a supertype of every dictionary entry
 800 type.
 801 </p>
 802 </div>
 803 <hr>
 804 <div class="refsect2">
 805 <a name="G-VARIANT-TYPE-DICTIONARY:CAPS"></a><h3>G_VARIANT_TYPE_DICTIONARY</h3>
 806 <pre class="programlisting">#define G_VARIANT_TYPE_DICTIONARY           ((const GVariantType *) "a{?*}")
 807 </pre>
 808 <p>
 809 An indefinite type that is a supertype of every dictionary type --
 810 that is, any array type that has an element type equal to any
 811 dictionary entry type.
 812 </p>
 813 </div>
 814 <hr>
 815 <div class="refsect2">
 816 <a name="G-VARIANT-TYPE-STRING-ARRAY:CAPS"></a><h3>G_VARIANT_TYPE_STRING_ARRAY</h3>
 817 <pre class="programlisting">#define G_VARIANT_TYPE_STRING_ARRAY         ((const GVariantType *) "as")
 818 </pre>
 819 <p>
 820 The type of an array of strings.
 821 </p>
 822 </div>
 823 <hr>
 824 <div class="refsect2">
 825 <a name="G-VARIANT-TYPE-OBJECT-PATH-ARRAY:CAPS"></a><h3>G_VARIANT_TYPE_OBJECT_PATH_ARRAY</h3>
 826 <pre class="programlisting">#define G_VARIANT_TYPE_OBJECT_PATH_ARRAY    ((const GVariantType *) "ao")
 827 </pre>
 828 <p>
 829 The type of an array of object paths.
 830 </p>
 831 </div>
 832 <hr>
 833 <div class="refsect2">
 834 <a name="G-VARIANT-TYPE-BYTESTRING:CAPS"></a><h3>G_VARIANT_TYPE_BYTESTRING</h3>
 835 <pre class="programlisting">#define G_VARIANT_TYPE_BYTESTRING           ((const GVariantType *) "ay")
 836 </pre>
 837 <p>
 838 The type of an array of bytes.  This type is commonly used to pass
 839 around strings that may not be valid utf8.  In that case, the
 840 convention is that the nul terminator character should be included as
 841 the last character in the array.
 842 </p>
 843 </div>
 844 <hr>
 845 <div class="refsect2">
 846 <a name="G-VARIANT-TYPE-BYTESTRING-ARRAY:CAPS"></a><h3>G_VARIANT_TYPE_BYTESTRING_ARRAY</h3>
 847 <pre class="programlisting">#define G_VARIANT_TYPE_BYTESTRING_ARRAY     ((const GVariantType *) "aay")
 848 </pre>
 849 <p>
 850 The type of an array of byte strings (an array of arrays of bytes).
 851 </p>
 852 </div>
 853 <hr>
 854 <div class="refsect2">
 855 <a name="G-VARIANT-TYPE-VARDICT:CAPS"></a><h3>G_VARIANT_TYPE_VARDICT</h3>
 856 <pre class="programlisting">#define G_VARIANT_TYPE_VARDICT              ((const GVariantType *) "a{sv}")
 857 </pre>
 858 <p>
 859 The type of a dictionary mapping strings to variants (the ubiquitous
 860 "a{sv}" type).
 861 </p>
 862 <p class="since">Since 2.30</p>
 863 </div>
 864 <hr>
 865 <div class="refsect2">
 866 <a name="G-VARIANT-TYPE:CAPS"></a><h3>G_VARIANT_TYPE()</h3>
 867 <pre class="programlisting"># define G_VARIANT_TYPE(type_string)            (g_variant_type_checked_ ((type_string)))
 868 </pre>
 869 <p>
 870 Converts a string to a const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>.  Depending on the
 871 current debugging level, this function may perform a runtime check
 872 to ensure that <em class="parameter"><code>string</code></em> is a valid GVariant type string.
 873 </p>
 874 <p>
 875 It is always a programmer error to use this macro with an invalid
 876 type string. If in doubt, use <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()"><code class="function">g_variant_type_string_is_valid()</code></a> to
 877 check if the string is valid.
 878 </p>
 879 <p>
 880 Since 2.24
 881 </p>
 882 <div class="variablelist"><table border="0">
 883 <col align="left" valign="top">
 884 <tbody><tr>
 885 <td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
 886 <td>a well-formed <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> type string</td>
 887 </tr></tbody>
 888 </table></div>
 889 </div>
 890 <hr>
 891 <div class="refsect2">
 892 <a name="g-variant-type-free"></a><h3>g_variant_type_free ()</h3>
 893 <pre class="programlisting"><span class="returnvalue">void</span>                g_variant_type_free                 (<em class="parameter"><code><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
 894 <p>
 895 Frees a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> that was allocated with
 896 <a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()"><code class="function">g_variant_type_copy()</code></a>, <a class="link" href="glib-GVariantType.html#g-variant-type-new" title="g_variant_type_new ()"><code class="function">g_variant_type_new()</code></a> or one of the container
 897 type constructor functions.
 898 </p>
 899 <p>
 900 In the case that <em class="parameter"><code>type</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>, this function does nothing.
 901 </p>
 902 <p>
 903 Since 2.24
 904 </p>
 905 <div class="variablelist"><table border="0">
 906 <col align="left" valign="top">
 907 <tbody><tr>
 908 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 909 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
 910 </td>
 911 </tr></tbody>
 912 </table></div>
 913 </div>
 914 <hr>
 915 <div class="refsect2">
 916 <a name="g-variant-type-copy"></a><h3>g_variant_type_copy ()</h3>
 917 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_copy                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
 918 <p>
 919 Makes a copy of a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>.  It is appropriate to call
 920 <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.  <em class="parameter"><code>type</code></em> may not be <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
 921 </p>
 922 <div class="variablelist"><table border="0">
 923 <col align="left" valign="top">
 924 <tbody>
 925 <tr>
 926 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 927 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
 928 </td>
 929 </tr>
 930 <tr>
 931 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 932 <td>a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
 933 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 934 </td>
 935 </tr>
 936 </tbody>
 937 </table></div>
 938 </div>
 939 <hr>
 940 <div class="refsect2">
 941 <a name="g-variant-type-new"></a><h3>g_variant_type_new ()</h3>
 942 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new                  (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);</pre>
 943 <p>
 944 Creates a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> corresponding to the type string given
 945 by <em class="parameter"><code>type_string</code></em>.  It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on
 946 the return value.
 947 </p>
 948 <p>
 949 It is a programmer error to call this function with an invalid type
 950 string.  Use <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()"><code class="function">g_variant_type_string_is_valid()</code></a> if you are unsure.
 951 </p>
 952 <div class="variablelist"><table border="0">
 953 <col align="left" valign="top">
 954 <tbody>
 955 <tr>
 956 <td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
 957 <td>a valid GVariant type string</td>
 958 </tr>
 959 <tr>
 960 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 961 <td>a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 962 </td>
 963 </tr>
 964 </tbody>
 965 </table></div>
 966 <p class="since">Since 2.24</p>
 967 </div>
 968 <hr>
 969 <div class="refsect2">
 970 <a name="g-variant-type-string-is-valid"></a><h3>g_variant_type_string_is_valid ()</h3>
 971 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_string_is_valid      (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);</pre>
 972 <p>
 973 Checks if <em class="parameter"><code>type_string</code></em> is a valid GVariant type string.  This call is
 974 equivalent to calling <a class="link" href="glib-GVariantType.html#g-variant-type-string-scan" title="g_variant_type_string_scan ()"><code class="function">g_variant_type_string_scan()</code></a> and confirming
 975 that the following character is a nul terminator.
 976 </p>
 977 <div class="variablelist"><table border="0">
 978 <col align="left" valign="top">
 979 <tbody>
 980 <tr>
 981 <td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
 982 <td>a pointer to any string</td>
 983 </tr>
 984 <tr>
 985 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 986 <td>
 987 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type_string</code></em> is exactly one valid type string
 988 Since 2.24</td>
 989 </tr>
 990 </tbody>
 991 </table></div>
 992 </div>
 993 <hr>
 994 <div class="refsect2">
 995 <a name="g-variant-type-string-scan"></a><h3>g_variant_type_string_scan ()</h3>
 996 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_string_scan          (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *string</code></em>,
 997                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *limit</code></em>,
 998                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> **endptr</code></em>);</pre>
 999 <p>
1000 Scan for a single complete and valid GVariant type string in <em class="parameter"><code>string</code></em>.
1001 The memory pointed to by <em class="parameter"><code>limit</code></em> (or bytes beyond it) is never
1002 accessed.
1003 </p>
1004 <p>
1005 If a valid type string is found, <em class="parameter"><code>endptr</code></em> is updated to point to the
1006 first character past the end of the string that was found and <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>
1007 is returned.
1008 </p>
1009 <p>
1010 If there is no valid type string starting at <em class="parameter"><code>string</code></em>, or if the type
1011 string does not end before <em class="parameter"><code>limit</code></em> then <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> is returned.
1012 </p>
1013 <p>
1014 For the simple case of checking if a string is a valid type string,
1015 see <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()"><code class="function">g_variant_type_string_is_valid()</code></a>.
1016 </p>
1017 <div class="variablelist"><table border="0">
1018 <col align="left" valign="top">
1019 <tbody>
1020 <tr>
1021 <td><p><span class="term"><em class="parameter"><code>string</code></em> :</span></p></td>
1022 <td>a pointer to any string</td>
1023 </tr>
1024 <tr>
1025 <td><p><span class="term"><em class="parameter"><code>limit</code></em> :</span></p></td>
1026 <td>the end of <em class="parameter"><code>string</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>. <span class="annotation">[<acronym title="NULL is ok, both for passing and for returning."><span class="acronym">allow-none</span></acronym>]</span>
1027 </td>
1028 </tr>
1029 <tr>
1030 <td><p><span class="term"><em class="parameter"><code>endptr</code></em> :</span></p></td>
1031 <td>location to store the end pointer, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>. <span class="annotation">[<acronym title="Parameter for returning results. Default is transfer full."><span class="acronym">out</span></acronym>][<acronym title="NULL is ok, both for passing and for returning."><span class="acronym">allow-none</span></acronym>]</span>
1032 </td>
1033 </tr>
1034 <tr>
1035 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1036 <td>
1037 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if a valid type string was found</td>
1038 </tr>
1039 </tbody>
1040 </table></div>
1041 <p class="since">Since 2.24</p>
1042 </div>
1043 <hr>
1044 <div class="refsect2">
1045 <a name="g-variant-type-get-string-length"></a><h3>g_variant_type_get_string_length ()</h3>
1046 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               g_variant_type_get_string_length    (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1047 <p>
1048 Returns the length of the type string corresponding to the given
1049 <em class="parameter"><code>type</code></em>.  This function must be used to determine the valid extent of
1050 the memory region returned by <a class="link" href="glib-GVariantType.html#g-variant-type-peek-string" title="g_variant_type_peek_string ()"><code class="function">g_variant_type_peek_string()</code></a>.
1051 </p>
1052 <div class="variablelist"><table border="0">
1053 <col align="left" valign="top">
1054 <tbody>
1055 <tr>
1056 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1057 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1058 </td>
1059 </tr>
1060 <tr>
1061 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1062 <td>the length of the corresponding type string
1063 Since 2.24</td>
1064 </tr>
1065 </tbody>
1066 </table></div>
1067 </div>
1068 <hr>
1069 <div class="refsect2">
1070 <a name="g-variant-type-peek-string"></a><h3>g_variant_type_peek_string ()</h3>
1071 <pre class="programlisting">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *       g_variant_type_peek_string          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1072 <p>
1073 Returns the type string corresponding to the given <em class="parameter"><code>type</code></em>.  The
1074 result is not nul-terminated; in order to determine its length you
1075 must call <a class="link" href="glib-GVariantType.html#g-variant-type-get-string-length" title="g_variant_type_get_string_length ()"><code class="function">g_variant_type_get_string_length()</code></a>.
1076 </p>
1077 <p>
1078 To get a nul-terminated string, see <a class="link" href="glib-GVariantType.html#g-variant-type-dup-string" title="g_variant_type_dup_string ()"><code class="function">g_variant_type_dup_string()</code></a>.
1079 </p>
1080 <div class="variablelist"><table border="0">
1081 <col align="left" valign="top">
1082 <tbody>
1083 <tr>
1084 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1085 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1086 </td>
1087 </tr>
1088 <tr>
1089 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1090 <td>the corresponding type string (not nul-terminated)
1091 Since 2.24</td>
1092 </tr>
1093 </tbody>
1094 </table></div>
1095 </div>
1096 <hr>
1097 <div class="refsect2">
1098 <a name="g-variant-type-dup-string"></a><h3>g_variant_type_dup_string ()</h3>
1099 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *             g_variant_type_dup_string           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1100 <p>
1101 Returns a newly-allocated copy of the type string corresponding to
1102 <em class="parameter"><code>type</code></em>.  The returned string is nul-terminated.  It is appropriate to
1103 call <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a> on the return value.
1104 </p>
1105 <div class="variablelist"><table border="0">
1106 <col align="left" valign="top">
1107 <tbody>
1108 <tr>
1109 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1110 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1111 </td>
1112 </tr>
1113 <tr>
1114 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1115 <td>the corresponding type string
1116 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1117 </td>
1118 </tr>
1119 </tbody>
1120 </table></div>
1121 </div>
1122 <hr>
1123 <div class="refsect2">
1124 <a name="g-variant-type-is-definite"></a><h3>g_variant_type_is_definite ()</h3>
1125 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_definite          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1126 <p>
1127 Determines if the given <em class="parameter"><code>type</code></em> is definite (ie: not indefinite).
1128 </p>
1129 <p>
1130 A type is definite if its type string does not contain any indefinite
1131 type characters ('*', '?', or 'r').
1132 </p>
1133 <p>
1134 A <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a> instance may not have an indefinite type, so calling
1135 this function on the result of <a class="link" href="glib-GVariant.html#g-variant-get-type" title="g_variant_get_type ()"><code class="function">g_variant_get_type()</code></a> will always
1136 result in <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> being returned.  Calling this function on an
1137 indefinite type like <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, however, will result in
1138 <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> being returned.
1139 </p>
1140 <div class="variablelist"><table border="0">
1141 <col align="left" valign="top">
1142 <tbody>
1143 <tr>
1144 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1145 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1146 </td>
1147 </tr>
1148 <tr>
1149 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1150 <td>
1151 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is definite
1152 Since 2.24</td>
1153 </tr>
1154 </tbody>
1155 </table></div>
1156 </div>
1157 <hr>
1158 <div class="refsect2">
1159 <a name="g-variant-type-is-container"></a><h3>g_variant_type_is_container ()</h3>
1160 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_container         (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1161 <p>
1162 Determines if the given <em class="parameter"><code>type</code></em> is a container type.
1163 </p>
1164 <p>
1165 Container types are any array, maybe, tuple, or dictionary
1166 entry types plus the variant type.
1167 </p>
1168 <p>
1169 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
1170 definite subtype is a container -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, for
1171 example.
1172 </p>
1173 <div class="variablelist"><table border="0">
1174 <col align="left" valign="top">
1175 <tbody>
1176 <tr>
1177 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1178 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1179 </td>
1180 </tr>
1181 <tr>
1182 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1183 <td>
1184 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a container type
1185 Since 2.24</td>
1186 </tr>
1187 </tbody>
1188 </table></div>
1189 </div>
1190 <hr>
1191 <div class="refsect2">
1192 <a name="g-variant-type-is-basic"></a><h3>g_variant_type_is_basic ()</h3>
1193 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_basic             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1194 <p>
1195 Determines if the given <em class="parameter"><code>type</code></em> is a basic type.
1196 </p>
1197 <p>
1198 Basic types are booleans, bytes, integers, doubles, strings, object
1199 paths and signatures.
1200 </p>
1201 <p>
1202 Only a basic type may be used as the key of a dictionary entry.
1203 </p>
1204 <p>
1205 This function returns <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> for all indefinite types except
1206 <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC"><code class="literal">G_VARIANT_TYPE_BASIC</code></a>.
1207 </p>
1208 <div class="variablelist"><table border="0">
1209 <col align="left" valign="top">
1210 <tbody>
1211 <tr>
1212 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1213 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1214 </td>
1215 </tr>
1216 <tr>
1217 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1218 <td>
1219 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a basic type
1220 Since 2.24</td>
1221 </tr>
1222 </tbody>
1223 </table></div>
1224 </div>
1225 <hr>
1226 <div class="refsect2">
1227 <a name="g-variant-type-is-maybe"></a><h3>g_variant_type_is_maybe ()</h3>
1228 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_maybe             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1229 <p>
1230 Determines if the given <em class="parameter"><code>type</code></em> is a maybe type.  This is true if the
1231 type string for <em class="parameter"><code>type</code></em> starts with an 'm'.
1232 </p>
1233 <p>
1234 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
1235 definite subtype is a maybe type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-MAYBE:CAPS" title="G_VARIANT_TYPE_MAYBE"><code class="literal">G_VARIANT_TYPE_MAYBE</code></a>, for
1236 example.
1237 </p>
1238 <div class="variablelist"><table border="0">
1239 <col align="left" valign="top">
1240 <tbody>
1241 <tr>
1242 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1243 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1244 </td>
1245 </tr>
1246 <tr>
1247 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1248 <td>
1249 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a maybe type
1250 Since 2.24</td>
1251 </tr>
1252 </tbody>
1253 </table></div>
1254 </div>
1255 <hr>
1256 <div class="refsect2">
1257 <a name="g-variant-type-is-array"></a><h3>g_variant_type_is_array ()</h3>
1258 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_array             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1259 <p>
1260 Determines if the given <em class="parameter"><code>type</code></em> is an array type.  This is true if the
1261 type string for <em class="parameter"><code>type</code></em> starts with an 'a'.
1262 </p>
1263 <p>
1264 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
1265 definite subtype is an array type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, for
1266 example.
1267 </p>
1268 <div class="variablelist"><table border="0">
1269 <col align="left" valign="top">
1270 <tbody>
1271 <tr>
1272 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1273 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1274 </td>
1275 </tr>
1276 <tr>
1277 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1278 <td>
1279 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is an array type
1280 Since 2.24</td>
1281 </tr>
1282 </tbody>
1283 </table></div>
1284 </div>
1285 <hr>
1286 <div class="refsect2">
1287 <a name="g-variant-type-is-tuple"></a><h3>g_variant_type_is_tuple ()</h3>
1288 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_tuple             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1289 <p>
1290 Determines if the given <em class="parameter"><code>type</code></em> is a tuple type.  This is true if the
1291 type string for <em class="parameter"><code>type</code></em> starts with a '(' or if <em class="parameter"><code>type</code></em> is
1292 <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
1293 </p>
1294 <p>
1295 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
1296 definite subtype is a tuple type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>, for
1297 example.
1298 </p>
1299 <div class="variablelist"><table border="0">
1300 <col align="left" valign="top">
1301 <tbody>
1302 <tr>
1303 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1304 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1305 </td>
1306 </tr>
1307 <tr>
1308 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1309 <td>
1310 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a tuple type
1311 Since 2.24</td>
1312 </tr>
1313 </tbody>
1314 </table></div>
1315 </div>
1316 <hr>
1317 <div class="refsect2">
1318 <a name="g-variant-type-is-dict-entry"></a><h3>g_variant_type_is_dict_entry ()</h3>
1319 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_dict_entry        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1320 <p>
1321 Determines if the given <em class="parameter"><code>type</code></em> is a dictionary entry type.  This is
1322 true if the type string for <em class="parameter"><code>type</code></em> starts with a '{'.
1323 </p>
1324 <p>
1325 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
1326 definite subtype is a dictionary entry type --
1327 <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICT-ENTRY:CAPS" title="G_VARIANT_TYPE_DICT_ENTRY"><code class="literal">G_VARIANT_TYPE_DICT_ENTRY</code></a>, for example.
1328 </p>
1329 <div class="variablelist"><table border="0">
1330 <col align="left" valign="top">
1331 <tbody>
1332 <tr>
1333 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1334 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1335 </td>
1336 </tr>
1337 <tr>
1338 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1339 <td>
1340 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a dictionary entry type
1341 Since 2.24</td>
1342 </tr>
1343 </tbody>
1344 </table></div>
1345 </div>
1346 <hr>
1347 <div class="refsect2">
1348 <a name="g-variant-type-is-variant"></a><h3>g_variant_type_is_variant ()</h3>
1349 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_variant           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1350 <p>
1351 Determines if the given <em class="parameter"><code>type</code></em> is the variant type.
1352 </p>
1353 <div class="variablelist"><table border="0">
1354 <col align="left" valign="top">
1355 <tbody>
1356 <tr>
1357 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1358 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1359 </td>
1360 </tr>
1361 <tr>
1362 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1363 <td>
1364 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is the variant type
1365 Since 2.24</td>
1366 </tr>
1367 </tbody>
1368 </table></div>
1369 </div>
1370 <hr>
1371 <div class="refsect2">
1372 <a name="g-variant-type-hash"></a><h3>g_variant_type_hash ()</h3>
1373 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               g_variant_type_hash                 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type</code></em>);</pre>
1374 <p>
1375 Hashes <em class="parameter"><code>type</code></em>.
1376 </p>
1377 <p>
1378 The argument type of <em class="parameter"><code>type</code></em> is only <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> to allow use with
1379 <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a> without function pointer casting.  A valid
1380 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> must be provided.
1381 </p>
1382 <div class="variablelist"><table border="0">
1383 <col align="left" valign="top">
1384 <tbody>
1385 <tr>
1386 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1387 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GVariantType]</span>
1388 </td>
1389 </tr>
1390 <tr>
1391 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1392 <td>the hash value
1393 Since 2.24</td>
1394 </tr>
1395 </tbody>
1396 </table></div>
1397 </div>
1398 <hr>
1399 <div class="refsect2">
1400 <a name="g-variant-type-equal"></a><h3>g_variant_type_equal ()</h3>
1401 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_equal                (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type1</code></em>,
1402                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type2</code></em>);</pre>
1403 <p>
1404 Compares <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> for equality.
1405 </p>
1406 <p>
1407 Only returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the types are exactly equal.  Even if one type
1408 is an indefinite type and the other is a subtype of it, <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> will
1409 be returned if they are not exactly equal.  If you want to check for
1410 subtypes, use <a class="link" href="glib-GVariantType.html#g-variant-type-is-subtype-of" title="g_variant_type_is_subtype_of ()"><code class="function">g_variant_type_is_subtype_of()</code></a>.
1411 </p>
1412 <p>
1413 The argument types of <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> are only <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> to
1414 allow use with <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a> without function pointer casting.  For
1415 both arguments, a valid <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> must be provided.
1416 </p>
1417 <div class="variablelist"><table border="0">
1418 <col align="left" valign="top">
1419 <tbody>
1420 <tr>
1421 <td><p><span class="term"><em class="parameter"><code>type1</code></em> :</span></p></td>
1422 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GVariantType]</span>
1423 </td>
1424 </tr>
1425 <tr>
1426 <td><p><span class="term"><em class="parameter"><code>type2</code></em> :</span></p></td>
1427 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GVariantType]</span>
1428 </td>
1429 </tr>
1430 <tr>
1431 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1432 <td>
1433 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> are exactly equal
1434 Since 2.24</td>
1435 </tr>
1436 </tbody>
1437 </table></div>
1438 </div>
1439 <hr>
1440 <div class="refsect2">
1441 <a name="g-variant-type-is-subtype-of"></a><h3>g_variant_type_is_subtype_of ()</h3>
1442 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_subtype_of        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>,
1443                                                          <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *supertype</code></em>);</pre>
1444 <p>
1445 Checks if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>.
1446 </p>
1447 <p>
1448 This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>.  All
1449 types are considered to be subtypes of themselves.  Aside from that,
1450 only indefinite types can have subtypes.
1451 </p>
1452 <div class="variablelist"><table border="0">
1453 <col align="left" valign="top">
1454 <tbody>
1455 <tr>
1456 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1457 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1458 </td>
1459 </tr>
1460 <tr>
1461 <td><p><span class="term"><em class="parameter"><code>supertype</code></em> :</span></p></td>
1462 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1463 </td>
1464 </tr>
1465 <tr>
1466 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1467 <td>
1468 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>
1469 Since 2.24</td>
1470 </tr>
1471 </tbody>
1472 </table></div>
1473 </div>
1474 <hr>
1475 <div class="refsect2">
1476 <a name="g-variant-type-new-maybe"></a><h3>g_variant_type_new_maybe ()</h3>
1477 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_maybe            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);</pre>
1478 <p>
1479 Constructs the type corresponding to a maybe instance containing
1480 type <em class="parameter"><code>type</code></em> or Nothing.
1481 </p>
1482 <p>
1483 It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
1484 </p>
1485 <div class="variablelist"><table border="0">
1486 <col align="left" valign="top">
1487 <tbody>
1488 <tr>
1489 <td><p><span class="term"><em class="parameter"><code>element</code></em> :</span></p></td>
1490 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1491 </td>
1492 </tr>
1493 <tr>
1494 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1495 <td>a new maybe <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1496 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1497 </td>
1498 </tr>
1499 </tbody>
1500 </table></div>
1501 </div>
1502 <hr>
1503 <div class="refsect2">
1504 <a name="g-variant-type-new-array"></a><h3>g_variant_type_new_array ()</h3>
1505 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_array            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);</pre>
1506 <p>
1507 Constructs the type corresponding to an array of elements of the
1508 type <em class="parameter"><code>type</code></em>.
1509 </p>
1510 <p>
1511 It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
1512 </p>
1513 <div class="variablelist"><table border="0">
1514 <col align="left" valign="top">
1515 <tbody>
1516 <tr>
1517 <td><p><span class="term"><em class="parameter"><code>element</code></em> :</span></p></td>
1518 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1519 </td>
1520 </tr>
1521 <tr>
1522 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1523 <td>a new array <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1524 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1525 </td>
1526 </tr>
1527 </tbody>
1528 </table></div>
1529 </div>
1530 <hr>
1531 <div class="refsect2">
1532 <a name="g-variant-type-new-tuple"></a><h3>g_variant_type_new_tuple ()</h3>
1533 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_tuple            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> * const *items</code></em>,
1534                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="type">gint</span></a> length</code></em>);</pre>
1535 <p>
1536 Constructs a new tuple type, from <em class="parameter"><code>items</code></em>.
1537 </p>
1538 <p>
1539 <em class="parameter"><code>length</code></em> is the number of items in <em class="parameter"><code>items</code></em>, or -1 to indicate that
1540 <em class="parameter"><code>items</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>-terminated.
1541 </p>
1542 <p>
1543 It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
1544 </p>
1545 <div class="variablelist"><table border="0">
1546 <col align="left" valign="top">
1547 <tbody>
1548 <tr>
1549 <td><p><span class="term"><em class="parameter"><code>items</code></em> :</span></p></td>
1550 <td>an array of <a href="glib-GVariantType.html#GVariantType"><span class="type">GVariantTypes</span></a>, one for each item. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=length]</span>
1551 </td>
1552 </tr>
1553 <tr>
1554 <td><p><span class="term"><em class="parameter"><code>length</code></em> :</span></p></td>
1555 <td>the length of <em class="parameter"><code>items</code></em>, or -1</td>
1556 </tr>
1557 <tr>
1558 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1559 <td>a new tuple <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1560 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1561 </td>
1562 </tr>
1563 </tbody>
1564 </table></div>
1565 </div>
1566 <hr>
1567 <div class="refsect2">
1568 <a name="g-variant-type-new-dict-entry"></a><h3>g_variant_type_new_dict_entry ()</h3>
1569 <pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_dict_entry       (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *key</code></em>,
1570                                                          <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *value</code></em>);</pre>
1571 <p>
1572 Constructs the type corresponding to a dictionary entry with a key
1573 of type <em class="parameter"><code>key</code></em> and a value of type <em class="parameter"><code>value</code></em>.
1574 </p>
1575 <p>
1576 It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
1577 </p>
1578 <div class="variablelist"><table border="0">
1579 <col align="left" valign="top">
1580 <tbody>
1581 <tr>
1582 <td><p><span class="term"><em class="parameter"><code>key</code></em> :</span></p></td>
1583 <td>a basic <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1584 </td>
1585 </tr>
1586 <tr>
1587 <td><p><span class="term"><em class="parameter"><code>value</code></em> :</span></p></td>
1588 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1589 </td>
1590 </tr>
1591 <tr>
1592 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1593 <td>a new dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1594 Since 2.24. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1595 </td>
1596 </tr>
1597 </tbody>
1598 </table></div>
1599 </div>
1600 <hr>
1601 <div class="refsect2">
1602 <a name="g-variant-type-element"></a><h3>g_variant_type_element ()</h3>
1603 <pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_element             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1604 <p>
1605 Determines the element type of an array or maybe type.
1606 </p>
1607 <p>
1608 This function may only be used with array or maybe types.
1609 </p>
1610 <div class="variablelist"><table border="0">
1611 <col align="left" valign="top">
1612 <tbody>
1613 <tr>
1614 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1615 <td>an array or maybe <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1616 </td>
1617 </tr>
1618 <tr>
1619 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1620 <td>the element type of <em class="parameter"><code>type</code></em>
1621 Since 2.24. <span class="annotation">[<acronym title="Don't free data after the code is done."><span class="acronym">transfer none</span></acronym>]</span>
1622 </td>
1623 </tr>
1624 </tbody>
1625 </table></div>
1626 </div>
1627 <hr>
1628 <div class="refsect2">
1629 <a name="g-variant-type-n-items"></a><h3>g_variant_type_n_items ()</h3>
1630 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               g_variant_type_n_items              (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1631 <p>
1632 Determines the number of items contained in a tuple or
1633 dictionary entry type.
1634 </p>
1635 <p>
1636 This function may only be used with tuple or dictionary entry types,
1637 but must not be used with the generic tuple type
1638 <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
1639 </p>
1640 <p>
1641 In the case of a dictionary entry type, this function will always
1642 return 2.
1643 </p>
1644 <div class="variablelist"><table border="0">
1645 <col align="left" valign="top">
1646 <tbody>
1647 <tr>
1648 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1649 <td>a tuple or dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1650 </td>
1651 </tr>
1652 <tr>
1653 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1654 <td>the number of items in <em class="parameter"><code>type</code></em>
1655 Since 2.24</td>
1656 </tr>
1657 </tbody>
1658 </table></div>
1659 </div>
1660 <hr>
1661 <div class="refsect2">
1662 <a name="g-variant-type-first"></a><h3>g_variant_type_first ()</h3>
1663 <pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_first               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1664 <p>
1665 Determines the first item type of a tuple or dictionary entry
1666 type.
1667 </p>
1668 <p>
1669 This function may only be used with tuple or dictionary entry types,
1670 but must not be used with the generic tuple type
1671 <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
1672 </p>
1673 <p>
1674 In the case of a dictionary entry type, this returns the type of
1675 the key.
1676 </p>
1677 <p>
1678 <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is returned in case of <em class="parameter"><code>type</code></em> being <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UNIT:CAPS" title="G_VARIANT_TYPE_UNIT"><code class="literal">G_VARIANT_TYPE_UNIT</code></a>.
1679 </p>
1680 <p>
1681 This call, together with <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()"><code class="function">g_variant_type_next()</code></a> provides an iterator
1682 interface over tuple and dictionary entry types.
1683 </p>
1684 <div class="variablelist"><table border="0">
1685 <col align="left" valign="top">
1686 <tbody>
1687 <tr>
1688 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1689 <td>a tuple or dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1690 </td>
1691 </tr>
1692 <tr>
1693 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1694 <td>the first item type of <em class="parameter"><code>type</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
1695 Since 2.24. <span class="annotation">[<acronym title="Don't free data after the code is done."><span class="acronym">transfer none</span></acronym>]</span>
1696 </td>
1697 </tr>
1698 </tbody>
1699 </table></div>
1700 </div>
1701 <hr>
1702 <div class="refsect2">
1703 <a name="g-variant-type-next"></a><h3>g_variant_type_next ()</h3>
1704 <pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_next                (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1705 <p>
1706 Determines the next item type of a tuple or dictionary entry
1707 type.
1708 </p>
1709 <p>
1710 <em class="parameter"><code>type</code></em> must be the result of a previous call to
1711 <a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()"><code class="function">g_variant_type_first()</code></a> or <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()"><code class="function">g_variant_type_next()</code></a>.
1712 </p>
1713 <p>
1714 If called on the key type of a dictionary entry then this call
1715 returns the value type.  If called on the value type of a dictionary
1716 entry then this call returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
1717 </p>
1718 <p>
1719 For tuples, <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is returned when <em class="parameter"><code>type</code></em> is the last item in a tuple.
1720 </p>
1721 <div class="variablelist"><table border="0">
1722 <col align="left" valign="top">
1723 <tbody>
1724 <tr>
1725 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1726 <td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> from a previous call</td>
1727 </tr>
1728 <tr>
1729 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1730 <td>the next <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> after <em class="parameter"><code>type</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
1731 Since 2.24. <span class="annotation">[<acronym title="Don't free data after the code is done."><span class="acronym">transfer none</span></acronym>]</span>
1732 </td>
1733 </tr>
1734 </tbody>
1735 </table></div>
1736 </div>
1737 <hr>
1738 <div class="refsect2">
1739 <a name="g-variant-type-key"></a><h3>g_variant_type_key ()</h3>
1740 <pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_key                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1741 <p>
1742 Determines the key type of a dictionary entry type.
1743 </p>
1744 <p>
1745 This function may only be used with a dictionary entry type.  Other
1746 than the additional restriction, this call is equivalent to
1747 <a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()"><code class="function">g_variant_type_first()</code></a>.
1748 </p>
1749 <div class="variablelist"><table border="0">
1750 <col align="left" valign="top">
1751 <tbody>
1752 <tr>
1753 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1754 <td>a dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1755 </td>
1756 </tr>
1757 <tr>
1758 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1759 <td>the key type of the dictionary entry
1760 Since 2.24. <span class="annotation">[<acronym title="Don't free data after the code is done."><span class="acronym">transfer none</span></acronym>]</span>
1761 </td>
1762 </tr>
1763 </tbody>
1764 </table></div>
1765 </div>
1766 <hr>
1767 <div class="refsect2">
1768 <a name="g-variant-type-value"></a><h3>g_variant_type_value ()</h3>
1769 <pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_value               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
1770 <p>
1771 Determines the value type of a dictionary entry type.
1772 </p>
1773 <p>
1774 This function may only be used with a dictionary entry type.
1775 </p>
1776 <div class="variablelist"><table border="0">
1777 <col align="left" valign="top">
1778 <tbody>
1779 <tr>
1780 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
1781 <td>a dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
1782 </td>
1783 </tr>
1784 <tr>
1785 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1786 <td>the value type of the dictionary entry
1787 Since 2.24. <span class="annotation">[<acronym title="Don't free data after the code is done."><span class="acronym">transfer none</span></acronym>]</span>
1788 </td>
1789 </tr>
1790 </tbody>
1791 </table></div>
1792 </div>
1793 </div>
1794 <div class="refsect1">
1795 <a name="glib-GVariantType.see-also"></a><h2>See Also</h2>
1796 <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>, <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a>
1797 </div>
1798 </div>
1799 <div class="footer">
1800 <hr>
1801           Generated by GTK-Doc V1.18</div>
1802 </body>
1803 </html>