docs/reference/glib/html/glib-Byte-Arrays.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>Byte Arrays</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-Pointer-Arrays.html" title="Pointer Arrays">
  10 <link rel="next" href="glib-Balanced-Binary-Trees.html" title="Balanced Binary Trees">
  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-Pointer-Arrays.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-Balanced-Binary-Trees.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-Byte-Arrays.synopsis" class="shortcut">Top</a>
  25                    |
  26                   <a href="#glib-Byte-Arrays.description" class="shortcut">Description</a>
  27 </td></tr>
  28 </table>
  29 <div class="refentry">
  30 <a name="glib-Byte-Arrays"></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-Byte-Arrays.top_of_page"></a>Byte Arrays</span></h2>
  34 <p>Byte Arrays — arrays of bytes</p>
  35 </td>
  36 <td valign="top" align="right"></td>
  37 </tr></table></div>
  38 <div class="refsynopsisdiv">
  39 <a name="glib-Byte-Arrays.synopsis"></a><h2>Synopsis</h2>
  40 <pre class="synopsis">
  41 #include &lt;glib.h&gt;
  42
  43 struct              <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray">GByteArray</a>;
  44 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-new" title="g_byte_array_new ()">g_byte_array_new</a>                    (<em class="parameter"><code><span class="type">void</span></code></em>);
  45 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-new-take" title="g_byte_array_new_take ()">g_byte_array_new_take</a>               (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
  46                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> len</code></em>);
  47 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-sized-new" title="g_byte_array_sized_new ()">g_byte_array_sized_new</a>              (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> reserved_size</code></em>);
  48 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-ref" title="g_byte_array_ref ()">g_byte_array_ref</a>                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);
  49 <span class="returnvalue">void</span>                <a class="link" href="glib-Byte-Arrays.html#g-byte-array-unref" title="g_byte_array_unref ()">g_byte_array_unref</a>                  (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);
  50 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-append" title="g_byte_array_append ()">g_byte_array_append</a>                 (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  51                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
  52                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> len</code></em>);
  53 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-prepend" title="g_byte_array_prepend ()">g_byte_array_prepend</a>                (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  54                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
  55                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> len</code></em>);
  56 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-remove-index" title="g_byte_array_remove_index ()">g_byte_array_remove_index</a>           (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  57                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>);
  58 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-remove-index-fast" title="g_byte_array_remove_index_fast ()">g_byte_array_remove_index_fast</a>      (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  59                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>);
  60 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-remove-range" title="g_byte_array_remove_range ()">g_byte_array_remove_range</a>           (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  61                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>,
  62                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> length</code></em>);
  63 <span class="returnvalue">void</span>                <a class="link" href="glib-Byte-Arrays.html#g-byte-array-sort" title="g_byte_array_sort ()">g_byte_array_sort</a>                   (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  64                                                          <em class="parameter"><code><a class="link" href="glib-Doubly-Linked-Lists.html#GCompareFunc" title="GCompareFunc ()"><span class="type">GCompareFunc</span></a> compare_func</code></em>);
  65 <span class="returnvalue">void</span>                <a class="link" href="glib-Byte-Arrays.html#g-byte-array-sort-with-data" title="g_byte_array_sort_with_data ()">g_byte_array_sort_with_data</a>         (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  66                                                          <em class="parameter"><code><a class="link" href="glib-Doubly-Linked-Lists.html#GCompareDataFunc" title="GCompareDataFunc ()"><span class="type">GCompareDataFunc</span></a> compare_func</code></em>,
  67                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);
  68 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-byte-array-set-size" title="g_byte_array_set_size ()">g_byte_array_set_size</a>               (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  69                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> length</code></em>);
  70 <a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="returnvalue">guint8</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free" title="g_byte_array_free ()">g_byte_array_free</a>                   (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
  71                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="type">gboolean</span></a> free_segment</code></em>);
  72 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free-to-bytes" title="g_byte_array_free_to_bytes ()">g_byte_array_free_to_bytes</a>          (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);
  73
  74                     <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes">GBytes</a>;
  75 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-new" title="g_bytes_new ()">g_bytes_new</a>                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
  76                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);
  77 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-take" title="g_bytes_new_take ()">g_bytes_new_take</a>                    (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> data</code></em>,
  78                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);
  79 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-static" title="g_bytes_new_static ()">g_bytes_new_static</a>                  (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
  80                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);
  81 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-with-free-func" title="g_bytes_new_with_free_func ()">g_bytes_new_with_free_func</a>          (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
  82                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>,
  83                                                          <em class="parameter"><code><a class="link" href="glib-Datasets.html#GDestroyNotify" title="GDestroyNotify ()"><span class="type">GDestroyNotify</span></a> free_func</code></em>,
  84                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);
  85 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-from-bytes" title="g_bytes_new_from_bytes ()">g_bytes_new_from_bytes</a>              (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
  86                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> offset</code></em>,
  87                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> length</code></em>);
  88 <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a>       <a class="link" href="glib-Byte-Arrays.html#g-bytes-get-data" title="g_bytes_get_data ()">g_bytes_get_data</a>                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
  89                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> *size</code></em>);
  90 <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               <a class="link" href="glib-Byte-Arrays.html#g-bytes-get-size" title="g_bytes_get_size ()">g_bytes_get_size</a>                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);
  91 <a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               <a class="link" href="glib-Byte-Arrays.html#g-bytes-hash" title="g_bytes_hash ()">g_bytes_hash</a>                        (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes</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-Byte-Arrays.html#g-bytes-equal" title="g_bytes_equal ()">g_bytes_equal</a>                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes1</code></em>,
  93                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes2</code></em>);
  94 <a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a>                <a class="link" href="glib-Byte-Arrays.html#g-bytes-compare" title="g_bytes_compare ()">g_bytes_compare</a>                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes1</code></em>,
  95                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes2</code></em>);
  96 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            <a class="link" href="glib-Byte-Arrays.html#g-bytes-ref" title="g_bytes_ref ()">g_bytes_ref</a>                         (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);
  97 <span class="returnvalue">void</span>                <a class="link" href="glib-Byte-Arrays.html#g-bytes-unref" title="g_bytes_unref ()">g_bytes_unref</a>                       (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);
  98 <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Byte-Arrays.html#g-bytes-unref-to-data" title="g_bytes_unref_to_data ()">g_bytes_unref_to_data</a>               (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
  99                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> *size</code></em>);
 100 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        <a class="link" href="glib-Byte-Arrays.html#g-bytes-unref-to-array" title="g_bytes_unref_to_array ()">g_bytes_unref_to_array</a>              (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);
 101 </pre>
 102 </div>
 103 <div class="refsect1">
 104 <a name="glib-Byte-Arrays.description"></a><h2>Description</h2>
 105 <p>
 106 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> is a mutable array of bytes based on <a class="link" href="glib-Arrays.html#GArray" title="struct GArray"><span class="type">GArray</span></a>, to provide arrays
 107 of bytes which grow automatically as elements are added.
 108 </p>
 109 <p>
 110 To create a new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> use <a class="link" href="glib-Byte-Arrays.html#g-byte-array-new" title="g_byte_array_new ()"><code class="function">g_byte_array_new()</code></a>. To add elements to a
 111 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>, use <a class="link" href="glib-Byte-Arrays.html#g-byte-array-append" title="g_byte_array_append ()"><code class="function">g_byte_array_append()</code></a>, and <a class="link" href="glib-Byte-Arrays.html#g-byte-array-prepend" title="g_byte_array_prepend ()"><code class="function">g_byte_array_prepend()</code></a>.
 112 </p>
 113 <p>
 114 To set the size of a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>, use <a class="link" href="glib-Byte-Arrays.html#g-byte-array-set-size" title="g_byte_array_set_size ()"><code class="function">g_byte_array_set_size()</code></a>.
 115 </p>
 116 <p>
 117 To free a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>, use <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free" title="g_byte_array_free ()"><code class="function">g_byte_array_free()</code></a>.
 118 </p>
 119 <p>
 120 </p>
 121 <div class="example">
 122 <a name="idp53436928"></a><p class="title"><b>Example 17. Using a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a></b></p>
 123 <div class="example-contents"><pre class="programlisting">
 124   GByteArray *gbarray;
 125   gint i;
 126
 127   gbarray = g_byte_array_new ();
 128   for (i = 0; i &lt; 10000; i++)
 129     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 130
 131   for (i = 0; i &lt; 10000; i++)
 132     {
 133       g_assert (gbarray-&gt;data[4*i] == 'a');
 134       g_assert (gbarray-&gt;data[4*i+1] == 'b');
 135       g_assert (gbarray-&gt;data[4*i+2] == 'c');
 136       g_assert (gbarray-&gt;data[4*i+3] == 'd');
 137     }
 138
 139   g_byte_array_free (gbarray, TRUE);
 140  </pre></div>
 141 </div>
 142 <p><br class="example-break">
 143 </p>
 144 <p>
 145 See <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> if you are interested in an immutable object representing a
 146 sequence of bytes.
 147 </p>
 148 </div>
 149 <div class="refsect1">
 150 <a name="glib-Byte-Arrays.details"></a><h2>Details</h2>
 151 <div class="refsect2">
 152 <a name="GByteArray"></a><h3>struct GByteArray</h3>
 153 <pre class="programlisting">struct GByteArray {
 154   guint8 *data;
 155   guint   len;
 156 };
 157 </pre>
 158 <p>
 159 The <span class="structname">GByteArray</span> struct allows access to the
 160 public fields of a <span class="structname">GByteArray</span>.
 161 </p>
 162 <div class="variablelist"><table border="0">
 163 <col align="left" valign="top">
 164 <tbody>
 165 <tr>
 166 <td><p><span class="term"><a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *<em class="structfield"><code><a name="GByteArray.data"></a>data</code></em>;</span></p></td>
 167 <td>a pointer to the element data. The data may be moved as
 168 elements are added to the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 169 </tr>
 170 <tr>
 171 <td><p><span class="term"><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> <em class="structfield"><code><a name="GByteArray.len"></a>len</code></em>;</span></p></td>
 172 <td>the number of elements in the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 173 </tr>
 174 </tbody>
 175 </table></div>
 176 </div>
 177 <hr>
 178 <div class="refsect2">
 179 <a name="g-byte-array-new"></a><h3>g_byte_array_new ()</h3>
 180 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_new                    (<em class="parameter"><code><span class="type">void</span></code></em>);</pre>
 181 <p>
 182 Creates a new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> with a reference count of 1.
 183 </p>
 184 <div class="variablelist"><table border="0">
 185 <col align="left" valign="top">
 186 <tbody><tr>
 187 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 188 <td>the new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 189 </tr></tbody>
 190 </table></div>
 191 </div>
 192 <hr>
 193 <div class="refsect2">
 194 <a name="g-byte-array-new-take"></a><h3>g_byte_array_new_take ()</h3>
 195 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_new_take               (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
 196                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> len</code></em>);</pre>
 197 <p>
 198 Create byte array containing the data. The data will be owned by the array
 199 and will be freed with <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>, i.e. it could be allocated using <a class="link" href="glib-String-Utility-Functions.html#g-strdup" title="g_strdup ()"><code class="function">g_strdup()</code></a>.
 200 </p>
 201 <div class="variablelist"><table border="0">
 202 <col align="left" valign="top">
 203 <tbody>
 204 <tr>
 205 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 206 <td>byte data for the array. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=len]</span>
 207 </td>
 208 </tr>
 209 <tr>
 210 <td><p><span class="term"><em class="parameter"><code>len</code></em> :</span></p></td>
 211 <td>length of <em class="parameter"><code>data</code></em>
 212 </td>
 213 </tr>
 214 <tr>
 215 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 216 <td>a new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 217 </td>
 218 </tr>
 219 </tbody>
 220 </table></div>
 221 <p class="since">Since 2.32</p>
 222 </div>
 223 <hr>
 224 <div class="refsect2">
 225 <a name="g-byte-array-sized-new"></a><h3>g_byte_array_sized_new ()</h3>
 226 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_sized_new              (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> reserved_size</code></em>);</pre>
 227 <p>
 228 Creates a new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> with <em class="parameter"><code>reserved_size</code></em> bytes preallocated.
 229 This avoids frequent reallocation, if you are going to add many
 230 bytes to the array. Note however that the size of the array is still
 231 0.
 232 </p>
 233 <div class="variablelist"><table border="0">
 234 <col align="left" valign="top">
 235 <tbody>
 236 <tr>
 237 <td><p><span class="term"><em class="parameter"><code>reserved_size</code></em> :</span></p></td>
 238 <td>number of bytes preallocated.</td>
 239 </tr>
 240 <tr>
 241 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 242 <td>the new <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 243 </tr>
 244 </tbody>
 245 </table></div>
 246 </div>
 247 <hr>
 248 <div class="refsect2">
 249 <a name="g-byte-array-ref"></a><h3>g_byte_array_ref ()</h3>
 250 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_ref                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);</pre>
 251 <p>
 252 Atomically increments the reference count of <em class="parameter"><code>array</code></em> by one. This
 253 function is MT-safe and may be called from any thread.
 254 </p>
 255 <div class="variablelist"><table border="0">
 256 <col align="left" valign="top">
 257 <tbody>
 258 <tr>
 259 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 260 <td>A <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 261 </tr>
 262 <tr>
 263 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 264 <td>The passed in <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 265 </tr>
 266 </tbody>
 267 </table></div>
 268 <p class="since">Since 2.22</p>
 269 </div>
 270 <hr>
 271 <div class="refsect2">
 272 <a name="g-byte-array-unref"></a><h3>g_byte_array_unref ()</h3>
 273 <pre class="programlisting"><span class="returnvalue">void</span>                g_byte_array_unref                  (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);</pre>
 274 <p>
 275 Atomically decrements the reference count of <em class="parameter"><code>array</code></em> by one. If the
 276 reference count drops to 0, all memory allocated by the array is
 277 released. This function is MT-safe and may be called from any
 278 thread.
 279 </p>
 280 <div class="variablelist"><table border="0">
 281 <col align="left" valign="top">
 282 <tbody><tr>
 283 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 284 <td>A <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 285 </tr></tbody>
 286 </table></div>
 287 <p class="since">Since 2.22</p>
 288 </div>
 289 <hr>
 290 <div class="refsect2">
 291 <a name="g-byte-array-append"></a><h3>g_byte_array_append ()</h3>
 292 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_append                 (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 293                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
 294                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> len</code></em>);</pre>
 295 <p>
 296 Adds the given bytes to the end of the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. The array will
 297 grow in size automatically if necessary.
 298 </p>
 299 <div class="variablelist"><table border="0">
 300 <col align="left" valign="top">
 301 <tbody>
 302 <tr>
 303 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 304 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 305 </tr>
 306 <tr>
 307 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 308 <td>the byte data to be added.</td>
 309 </tr>
 310 <tr>
 311 <td><p><span class="term"><em class="parameter"><code>len</code></em> :</span></p></td>
 312 <td>the number of bytes to add.</td>
 313 </tr>
 314 <tr>
 315 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 316 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 317 </tr>
 318 </tbody>
 319 </table></div>
 320 </div>
 321 <hr>
 322 <div class="refsect2">
 323 <a name="g-byte-array-prepend"></a><h3>g_byte_array_prepend ()</h3>
 324 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_prepend                (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 325                                                          <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="type">guint8</span></a> *data</code></em>,
 326                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> len</code></em>);</pre>
 327 <p>
 328 Adds the given data to the start of the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. The array will
 329 grow in size automatically if necessary.
 330 </p>
 331 <div class="variablelist"><table border="0">
 332 <col align="left" valign="top">
 333 <tbody>
 334 <tr>
 335 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 336 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 337 </tr>
 338 <tr>
 339 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 340 <td>the byte data to be added.</td>
 341 </tr>
 342 <tr>
 343 <td><p><span class="term"><em class="parameter"><code>len</code></em> :</span></p></td>
 344 <td>the number of bytes to add.</td>
 345 </tr>
 346 <tr>
 347 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 348 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 349 </tr>
 350 </tbody>
 351 </table></div>
 352 </div>
 353 <hr>
 354 <div class="refsect2">
 355 <a name="g-byte-array-remove-index"></a><h3>g_byte_array_remove_index ()</h3>
 356 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_remove_index           (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 357                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>);</pre>
 358 <p>
 359 Removes the byte at the given index from a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. The
 360 following bytes are moved down one place.
 361 </p>
 362 <div class="variablelist"><table border="0">
 363 <col align="left" valign="top">
 364 <tbody>
 365 <tr>
 366 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 367 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 368 </tr>
 369 <tr>
 370 <td><p><span class="term"><em class="parameter"><code>index_</code></em> :</span></p></td>
 371 <td>the index of the byte to remove.</td>
 372 </tr>
 373 <tr>
 374 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 375 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 376 </tr>
 377 </tbody>
 378 </table></div>
 379 </div>
 380 <hr>
 381 <div class="refsect2">
 382 <a name="g-byte-array-remove-index-fast"></a><h3>g_byte_array_remove_index_fast ()</h3>
 383 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_remove_index_fast      (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 384                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>);</pre>
 385 <p>
 386 Removes the byte at the given index from a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. The last
 387 element in the array is used to fill in the space, so this function
 388 does not preserve the order of the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. But it is faster
 389 than <a class="link" href="glib-Byte-Arrays.html#g-byte-array-remove-index" title="g_byte_array_remove_index ()"><code class="function">g_byte_array_remove_index()</code></a>.
 390 </p>
 391 <div class="variablelist"><table border="0">
 392 <col align="left" valign="top">
 393 <tbody>
 394 <tr>
 395 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 396 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 397 </tr>
 398 <tr>
 399 <td><p><span class="term"><em class="parameter"><code>index_</code></em> :</span></p></td>
 400 <td>the index of the byte to remove.</td>
 401 </tr>
 402 <tr>
 403 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 404 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 405 </tr>
 406 </tbody>
 407 </table></div>
 408 </div>
 409 <hr>
 410 <div class="refsect2">
 411 <a name="g-byte-array-remove-range"></a><h3>g_byte_array_remove_range ()</h3>
 412 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_remove_range           (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 413                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> index_</code></em>,
 414                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> length</code></em>);</pre>
 415 <p>
 416 Removes the given number of bytes starting at the given index from a
 417 <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.  The following elements are moved to close the gap.
 418 </p>
 419 <div class="variablelist"><table border="0">
 420 <col align="left" valign="top">
 421 <tbody>
 422 <tr>
 423 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 424 <td>a <em class="parameter"><code>GByteArray</code></em>.</td>
 425 </tr>
 426 <tr>
 427 <td><p><span class="term"><em class="parameter"><code>index_</code></em> :</span></p></td>
 428 <td>the index of the first byte to remove.</td>
 429 </tr>
 430 <tr>
 431 <td><p><span class="term"><em class="parameter"><code>length</code></em> :</span></p></td>
 432 <td>the number of bytes to remove.</td>
 433 </tr>
 434 <tr>
 435 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 436 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 437 </tr>
 438 </tbody>
 439 </table></div>
 440 <p class="since">Since 2.4</p>
 441 </div>
 442 <hr>
 443 <div class="refsect2">
 444 <a name="g-byte-array-sort"></a><h3>g_byte_array_sort ()</h3>
 445 <pre class="programlisting"><span class="returnvalue">void</span>                g_byte_array_sort                   (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 446                                                          <em class="parameter"><code><a class="link" href="glib-Doubly-Linked-Lists.html#GCompareFunc" title="GCompareFunc ()"><span class="type">GCompareFunc</span></a> compare_func</code></em>);</pre>
 447 <p>
 448 Sorts a byte array, using <em class="parameter"><code>compare_func</code></em> which should be a
 449 <code class="function">qsort()</code>-style comparison function (returns less than zero for first
 450 arg is less than second arg, zero for equal, greater than zero if
 451 first arg is greater than second arg).
 452 </p>
 453 <p>
 454 If two array elements compare equal, their order in the sorted array
 455 is undefined. If you want equal elements to keep their order (i.e.
 456 you want a stable sort) you can write a comparison function that,
 457 if two elements would otherwise compare equal, compares them by
 458 their addresses.
 459 </p>
 460 <div class="variablelist"><table border="0">
 461 <col align="left" valign="top">
 462 <tbody>
 463 <tr>
 464 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 465 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 466 </tr>
 467 <tr>
 468 <td><p><span class="term"><em class="parameter"><code>compare_func</code></em> :</span></p></td>
 469 <td>comparison function.</td>
 470 </tr>
 471 </tbody>
 472 </table></div>
 473 </div>
 474 <hr>
 475 <div class="refsect2">
 476 <a name="g-byte-array-sort-with-data"></a><h3>g_byte_array_sort_with_data ()</h3>
 477 <pre class="programlisting"><span class="returnvalue">void</span>                g_byte_array_sort_with_data         (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 478                                                          <em class="parameter"><code><a class="link" href="glib-Doubly-Linked-Lists.html#GCompareDataFunc" title="GCompareDataFunc ()"><span class="type">GCompareDataFunc</span></a> compare_func</code></em>,
 479                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);</pre>
 480 <p>
 481 Like <a class="link" href="glib-Byte-Arrays.html#g-byte-array-sort" title="g_byte_array_sort ()"><code class="function">g_byte_array_sort()</code></a>, but the comparison function takes an extra
 482 user data argument.
 483 </p>
 484 <div class="variablelist"><table border="0">
 485 <col align="left" valign="top">
 486 <tbody>
 487 <tr>
 488 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 489 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 490 </tr>
 491 <tr>
 492 <td><p><span class="term"><em class="parameter"><code>compare_func</code></em> :</span></p></td>
 493 <td>comparison function.</td>
 494 </tr>
 495 <tr>
 496 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
 497 <td>data to pass to <em class="parameter"><code>compare_func</code></em>.</td>
 498 </tr>
 499 </tbody>
 500 </table></div>
 501 </div>
 502 <hr>
 503 <div class="refsect2">
 504 <a name="g-byte-array-set-size"></a><h3>g_byte_array_set_size ()</h3>
 505 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_byte_array_set_size               (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 506                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> length</code></em>);</pre>
 507 <p>
 508 Sets the size of the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>, expanding it if necessary.
 509 </p>
 510 <div class="variablelist"><table border="0">
 511 <col align="left" valign="top">
 512 <tbody>
 513 <tr>
 514 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 515 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 516 </tr>
 517 <tr>
 518 <td><p><span class="term"><em class="parameter"><code>length</code></em> :</span></p></td>
 519 <td>the new size of the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 520 </tr>
 521 <tr>
 522 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 523 <td>the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 524 </tr>
 525 </tbody>
 526 </table></div>
 527 </div>
 528 <hr>
 529 <div class="refsect2">
 530 <a name="g-byte-array-free"></a><h3>g_byte_array_free ()</h3>
 531 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#guint8" title="guint8"><span class="returnvalue">guint8</span></a> *            g_byte_array_free                   (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>,
 532                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="type">gboolean</span></a> free_segment</code></em>);</pre>
 533 <p>
 534 Frees the memory allocated by the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. If <em class="parameter"><code>free_segment</code></em> is
 535 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> it frees the actual byte data. If the reference count of
 536 <em class="parameter"><code>array</code></em> is greater than one, the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> wrapper is preserved but
 537 the size of <em class="parameter"><code>array</code></em> will be set to zero.
 538 </p>
 539 <div class="variablelist"><table border="0">
 540 <col align="left" valign="top">
 541 <tbody>
 542 <tr>
 543 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 544 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>.</td>
 545 </tr>
 546 <tr>
 547 <td><p><span class="term"><em class="parameter"><code>free_segment</code></em> :</span></p></td>
 548 <td>if <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> the actual byte data is freed as well.</td>
 549 </tr>
 550 <tr>
 551 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 552 <td>the element data if <em class="parameter"><code>free_segment</code></em> is <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a>, otherwise
 553 <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.  The element data should be freed using <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>.</td>
 554 </tr>
 555 </tbody>
 556 </table></div>
 557 </div>
 558 <hr>
 559 <div class="refsect2">
 560 <a name="g-byte-array-free-to-bytes"></a><h3>g_byte_array_free_to_bytes ()</h3>
 561 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_byte_array_free_to_bytes          (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> *array</code></em>);</pre>
 562 <p>
 563 Transfers the data from the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> into a new immutable <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>.
 564 </p>
 565 <p>
 566 The <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> is freed unless the reference count of <em class="parameter"><code>array</code></em> is greater
 567 than one, the <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> wrapper is preserved but the size of <em class="parameter"><code>array</code></em>
 568 will be set to zero.
 569 </p>
 570 <p>
 571 This is identical to using <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-take" title="g_bytes_new_take ()"><code class="function">g_bytes_new_take()</code></a> and <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free" title="g_byte_array_free ()"><code class="function">g_byte_array_free()</code></a>
 572 together.
 573 </p>
 574 <div class="variablelist"><table border="0">
 575 <col align="left" valign="top">
 576 <tbody>
 577 <tr>
 578 <td><p><span class="term"><em class="parameter"><code>array</code></em> :</span></p></td>
 579 <td>a <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 580 </td>
 581 </tr>
 582 <tr>
 583 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 584 <td>a new immutable <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> representing same byte
 585 data that was in the array. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 586 </td>
 587 </tr>
 588 </tbody>
 589 </table></div>
 590 <p class="since">Since 2.32</p>
 591 </div>
 592 <hr>
 593 <div class="refsect2">
 594 <a name="GBytes"></a><h3>GBytes</h3>
 595 <pre class="programlisting">typedef struct _GBytes GBytes;</pre>
 596 <p>
 597 A simple refcounted data type representing an immutable byte sequence
 598 from an unspecified origin.
 599 </p>
 600 <p>
 601 The purpose of a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> is to keep the memory region that it holds
 602 alive for as long as anyone holds a reference to the bytes.  When
 603 the last reference count is dropped, the memory is released. Multiple
 604 unrelated callers can use byte data in the <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> without coordinating
 605 their activities, resting assured that the byte data will not change or
 606 move while they hold a reference.
 607 </p>
 608 <p>
 609 A <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> can come from many different origins that may have
 610 different procedures for freeing the memory region.  Examples are
 611 memory from <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, from memory slices, from a <a class="link" href="glib-File-Utilities.html#GMappedFile" title="GMappedFile"><span class="type">GMappedFile</span></a> or
 612 memory from other allocators.
 613 </p>
 614 <p>
 615 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> work well as keys in <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a>. Use <a class="link" href="glib-Byte-Arrays.html#g-bytes-equal" title="g_bytes_equal ()"><code class="function">g_bytes_equal()</code></a> and
 616 <a class="link" href="glib-Byte-Arrays.html#g-bytes-hash" title="g_bytes_hash ()"><code class="function">g_bytes_hash()</code></a> as parameters to <a class="link" href="glib-Hash-Tables.html#g-hash-table-new" title="g_hash_table_new ()"><code class="function">g_hash_table_new()</code></a> or <a class="link" href="glib-Hash-Tables.html#g-hash-table-new-full" title="g_hash_table_new_full ()"><code class="function">g_hash_table_new_full()</code></a>.
 617 <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> can also be used as keys in a <a class="link" href="glib-Balanced-Binary-Trees.html#GTree" title="GTree"><span class="type">GTree</span></a> by passing the <a class="link" href="glib-Byte-Arrays.html#g-bytes-compare" title="g_bytes_compare ()"><code class="function">g_bytes_compare()</code></a>
 618 function to <a class="link" href="glib-Balanced-Binary-Trees.html#g-tree-new" title="g_tree_new ()"><code class="function">g_tree_new()</code></a>.
 619 </p>
 620 <p>
 621 The data pointed to by this bytes must not be modified. For a mutable
 622 array of bytes see <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>. Use <a class="link" href="glib-Byte-Arrays.html#g-bytes-unref-to-array" title="g_bytes_unref_to_array ()"><code class="function">g_bytes_unref_to_array()</code></a> to create a
 623 mutable array for a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> sequence. To create an immutable <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> from
 624 a mutable <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a>, use the <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free-to-bytes" title="g_byte_array_free_to_bytes ()"><code class="function">g_byte_array_free_to_bytes()</code></a> function.
 625 </p>
 626 <p class="since">Since 2.32</p>
 627 </div>
 628 <hr>
 629 <div class="refsect2">
 630 <a name="g-bytes-new"></a><h3>g_bytes_new ()</h3>
 631 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_new                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
 632                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);</pre>
 633 <p>
 634 Creates a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> from <em class="parameter"><code>data</code></em>.
 635 </p>
 636 <p>
 637 <em class="parameter"><code>data</code></em> is copied.
 638 </p>
 639 <div class="variablelist"><table border="0">
 640 <col align="left" valign="top">
 641 <tbody>
 642 <tr>
 643 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 644 <td>the data to be used for the bytes. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=size]</span>
 645 </td>
 646 </tr>
 647 <tr>
 648 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
 649 <td>the size of <em class="parameter"><code>data</code></em>
 650 </td>
 651 </tr>
 652 <tr>
 653 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 654 <td>a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 655 </td>
 656 </tr>
 657 </tbody>
 658 </table></div>
 659 <p class="since">Since 2.32</p>
 660 </div>
 661 <hr>
 662 <div class="refsect2">
 663 <a name="g-bytes-new-take"></a><h3>g_bytes_new_take ()</h3>
 664 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_new_take                    (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> data</code></em>,
 665                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);</pre>
 666 <p>
 667 Creates a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> from <em class="parameter"><code>data</code></em>.
 668 </p>
 669 <p>
 670 After this call, <em class="parameter"><code>data</code></em> belongs to the bytes and may no longer be
 671 modified by the caller.  <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a> will be called on <em class="parameter"><code>data</code></em> when the
 672 bytes is no longer in use. Because of this <em class="parameter"><code>data</code></em> must have been created by
 673 a call to <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()"><code class="function">g_malloc0()</code></a> or <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()"><code class="function">g_realloc()</code></a> or by one of the many
 674 functions that wrap these calls (such as <a class="link" href="glib-Memory-Allocation.html#g-new" title="g_new()"><code class="function">g_new()</code></a>, <a class="link" href="glib-String-Utility-Functions.html#g-strdup" title="g_strdup ()"><code class="function">g_strdup()</code></a>, etc).
 675 </p>
 676 <p>
 677 For creating <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> with memory from other allocators, see
 678 <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-with-free-func" title="g_bytes_new_with_free_func ()"><code class="function">g_bytes_new_with_free_func()</code></a>.
 679 </p>
 680 <div class="variablelist"><table border="0">
 681 <col align="left" valign="top">
 682 <tbody>
 683 <tr>
 684 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 685 <td>the data to be used for the bytes. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>][<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=size]</span>
 686 </td>
 687 </tr>
 688 <tr>
 689 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
 690 <td>the size of <em class="parameter"><code>data</code></em>
 691 </td>
 692 </tr>
 693 <tr>
 694 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 695 <td>a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 696 </td>
 697 </tr>
 698 </tbody>
 699 </table></div>
 700 <p class="since">Since 2.32</p>
 701 </div>
 702 <hr>
 703 <div class="refsect2">
 704 <a name="g-bytes-new-static"></a><h3>g_bytes_new_static ()</h3>
 705 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_new_static                  (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
 706                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>);</pre>
 707 <p>
 708 Creates a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> from static data.
 709 </p>
 710 <p>
 711 <em class="parameter"><code>data</code></em> must be static (ie: never modified or freed).
 712 </p>
 713 <div class="variablelist"><table border="0">
 714 <col align="left" valign="top">
 715 <tbody>
 716 <tr>
 717 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 718 <td>the data to be used for the bytes. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=size]</span>
 719 </td>
 720 </tr>
 721 <tr>
 722 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
 723 <td>the size of <em class="parameter"><code>data</code></em>
 724 </td>
 725 </tr>
 726 <tr>
 727 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 728 <td>a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 729 </td>
 730 </tr>
 731 </tbody>
 732 </table></div>
 733 <p class="since">Since 2.32</p>
 734 </div>
 735 <hr>
 736 <div class="refsect2">
 737 <a name="g-bytes-new-with-free-func"></a><h3>g_bytes_new_with_free_func ()</h3>
 738 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_new_with_free_func          (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> data</code></em>,
 739                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> size</code></em>,
 740                                                          <em class="parameter"><code><a class="link" href="glib-Datasets.html#GDestroyNotify" title="GDestroyNotify ()"><span class="type">GDestroyNotify</span></a> free_func</code></em>,
 741                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> user_data</code></em>);</pre>
 742 <p>
 743 Creates a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> from <em class="parameter"><code>data</code></em>.
 744 </p>
 745 <p>
 746 When the last reference is dropped, <em class="parameter"><code>free_func</code></em> will be called with the
 747 <em class="parameter"><code>user_data</code></em> argument.
 748 </p>
 749 <p>
 750 <em class="parameter"><code>data</code></em> must not be modified after this call is made until <em class="parameter"><code>free_func</code></em> has
 751 been called to indicate that the bytes is no longer in use.
 752 </p>
 753 <div class="variablelist"><table border="0">
 754 <col align="left" valign="top">
 755 <tbody>
 756 <tr>
 757 <td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
 758 <td>the data to be used for the bytes. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=size]</span>
 759 </td>
 760 </tr>
 761 <tr>
 762 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
 763 <td>the size of <em class="parameter"><code>data</code></em>
 764 </td>
 765 </tr>
 766 <tr>
 767 <td><p><span class="term"><em class="parameter"><code>free_func</code></em> :</span></p></td>
 768 <td>the function to call to release the data</td>
 769 </tr>
 770 <tr>
 771 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
 772 <td>data to pass to <em class="parameter"><code>free_func</code></em>
 773 </td>
 774 </tr>
 775 <tr>
 776 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 777 <td>a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 778 </td>
 779 </tr>
 780 </tbody>
 781 </table></div>
 782 <p class="since">Since 2.32</p>
 783 </div>
 784 <hr>
 785 <div class="refsect2">
 786 <a name="g-bytes-new-from-bytes"></a><h3>g_bytes_new_from_bytes ()</h3>
 787 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_new_from_bytes              (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
 788                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> offset</code></em>,
 789                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> length</code></em>);</pre>
 790 <p>
 791 Creates a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> which is a subsection of another <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. The <em class="parameter"><code>offset</code></em> +
 792 <em class="parameter"><code>length</code></em> may not be longer than the size of <em class="parameter"><code>bytes</code></em>.
 793 </p>
 794 <p>
 795 A reference to <em class="parameter"><code>bytes</code></em> will be held by the newly created <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> until
 796 the byte data is no longer needed.
 797 </p>
 798 <div class="variablelist"><table border="0">
 799 <col align="left" valign="top">
 800 <tbody>
 801 <tr>
 802 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
 803 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>
 804 </td>
 805 </tr>
 806 <tr>
 807 <td><p><span class="term"><em class="parameter"><code>offset</code></em> :</span></p></td>
 808 <td>offset which subsection starts at</td>
 809 </tr>
 810 <tr>
 811 <td><p><span class="term"><em class="parameter"><code>length</code></em> :</span></p></td>
 812 <td>length of subsection</td>
 813 </tr>
 814 <tr>
 815 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 816 <td>a new <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
 817 </td>
 818 </tr>
 819 </tbody>
 820 </table></div>
 821 <p class="since">Since 2.32</p>
 822 </div>
 823 <hr>
 824 <div class="refsect2">
 825 <a name="g-bytes-get-data"></a><h3>g_bytes_get_data ()</h3>
 826 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a>       g_bytes_get_data                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
 827                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> *size</code></em>);</pre>
 828 <p>
 829 Get the byte data in the <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. This data should not be modified.
 830 </p>
 831 <p>
 832 This function will always return the same pointer for a given <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>.
 833 </p>
 834 <div class="variablelist"><table border="0">
 835 <col align="left" valign="top">
 836 <tbody>
 837 <tr>
 838 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
 839 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>
 840 </td>
 841 </tr>
 842 <tr>
 843 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
 844 <td>location to return size of byte data. <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>
 845 </td>
 846 </tr>
 847 <tr>
 848 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 849 <td>a pointer to the byte data. <span class="annotation">[<acronym title="Parameter points to an array of items."><span class="acronym">array</span></acronym> length=size][<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> guint8]</span>
 850 </td>
 851 </tr>
 852 </tbody>
 853 </table></div>
 854 <p class="since">Since 2.32</p>
 855 </div>
 856 <hr>
 857 <div class="refsect2">
 858 <a name="g-bytes-get-size"></a><h3>g_bytes_get_size ()</h3>
 859 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               g_bytes_get_size                    (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);</pre>
 860 <p>
 861 Get the size of the byte data in the <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>.
 862 </p>
 863 <p>
 864 This function will always return the same value for a given <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>.
 865 </p>
 866 <div class="variablelist"><table border="0">
 867 <col align="left" valign="top">
 868 <tbody>
 869 <tr>
 870 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
 871 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>
 872 </td>
 873 </tr>
 874 <tr>
 875 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 876 <td>the size</td>
 877 </tr>
 878 </tbody>
 879 </table></div>
 880 <p class="since">Since 2.32</p>
 881 </div>
 882 <hr>
 883 <div class="refsect2">
 884 <a name="g-bytes-hash"></a><h3>g_bytes_hash ()</h3>
 885 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               g_bytes_hash                        (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes</code></em>);</pre>
 886 <p>
 887 Creates an integer hash code for the byte data in the <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>.
 888 </p>
 889 <p>
 890 This function can be passed to <a class="link" href="glib-Hash-Tables.html#g-hash-table-new" title="g_hash_table_new ()"><code class="function">g_hash_table_new()</code></a> as the <em class="parameter"><code>key_equal_func</code></em>
 891 parameter, when using non-<a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> pointers as keys in a <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a>.
 892 </p>
 893 <div class="variablelist"><table border="0">
 894 <col align="left" valign="top">
 895 <tbody>
 896 <tr>
 897 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
 898 <td>a pointer to a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> key. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GLib.Bytes]</span>
 899 </td>
 900 </tr>
 901 <tr>
 902 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 903 <td>a hash value corresponding to the key.</td>
 904 </tr>
 905 </tbody>
 906 </table></div>
 907 <p class="since">Since 2.32</p>
 908 </div>
 909 <hr>
 910 <div class="refsect2">
 911 <a name="g-bytes-equal"></a><h3>g_bytes_equal ()</h3>
 912 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_bytes_equal                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes1</code></em>,
 913                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes2</code></em>);</pre>
 914 <p>
 915 Compares the two <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> values being pointed to and returns
 916 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if they are equal.
 917 </p>
 918 <p>
 919 This function can be passed to <a class="link" href="glib-Hash-Tables.html#g-hash-table-new" title="g_hash_table_new ()"><code class="function">g_hash_table_new()</code></a> as the <em class="parameter"><code>key_equal_func</code></em>
 920 parameter, when using non-<a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> pointers as keys in a <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></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>bytes1</code></em> :</span></p></td>
 927 <td>a pointer to a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GLib.Bytes]</span>
 928 </td>
 929 </tr>
 930 <tr>
 931 <td><p><span class="term"><em class="parameter"><code>bytes2</code></em> :</span></p></td>
 932 <td>a pointer to a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> to compare with <em class="parameter"><code>bytes1</code></em>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GLib.Bytes]</span>
 933 </td>
 934 </tr>
 935 <tr>
 936 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 937 <td>
 938 <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the two keys match.</td>
 939 </tr>
 940 </tbody>
 941 </table></div>
 942 <p class="since">Since 2.32</p>
 943 </div>
 944 <hr>
 945 <div class="refsect2">
 946 <a name="g-bytes-compare"></a><h3>g_bytes_compare ()</h3>
 947 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a>                g_bytes_compare                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes1</code></em>,
 948                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> bytes2</code></em>);</pre>
 949 <p>
 950 Compares the two <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> values.
 951 </p>
 952 <p>
 953 This function can be used to sort GBytes instances in lexographical order.
 954 </p>
 955 <div class="variablelist"><table border="0">
 956 <col align="left" valign="top">
 957 <tbody>
 958 <tr>
 959 <td><p><span class="term"><em class="parameter"><code>bytes1</code></em> :</span></p></td>
 960 <td>a pointer to a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GLib.Bytes]</span>
 961 </td>
 962 </tr>
 963 <tr>
 964 <td><p><span class="term"><em class="parameter"><code>bytes2</code></em> :</span></p></td>
 965 <td>a pointer to a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> to compare with <em class="parameter"><code>bytes1</code></em>. <span class="annotation">[<acronym title="Override the parsed C type with given type"><span class="acronym">type</span></acronym> GLib.Bytes]</span>
 966 </td>
 967 </tr>
 968 <tr>
 969 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 970 <td>a negative value if bytes2 is lesser, a positive value if bytes2 is
 971 greater, and zero if bytes2 is equal to bytes1</td>
 972 </tr>
 973 </tbody>
 974 </table></div>
 975 <p class="since">Since 2.32</p>
 976 </div>
 977 <hr>
 978 <div class="refsect2">
 979 <a name="g-bytes-ref"></a><h3>g_bytes_ref ()</h3>
 980 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="returnvalue">GBytes</span></a> *            g_bytes_ref                         (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);</pre>
 981 <p>
 982 Increase the reference count on <em class="parameter"><code>bytes</code></em>.
 983 </p>
 984 <div class="variablelist"><table border="0">
 985 <col align="left" valign="top">
 986 <tbody>
 987 <tr>
 988 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
 989 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>
 990 </td>
 991 </tr>
 992 <tr>
 993 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 994 <td>the <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>
 995 </td>
 996 </tr>
 997 </tbody>
 998 </table></div>
 999 <p class="since">Since 2.32</p>
1000 </div>
1001 <hr>
1002 <div class="refsect2">
1003 <a name="g-bytes-unref"></a><h3>g_bytes_unref ()</h3>
1004 <pre class="programlisting"><span class="returnvalue">void</span>                g_bytes_unref                       (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);</pre>
1005 <p>
1006 Releases a reference on <em class="parameter"><code>bytes</code></em>.  This may result in the bytes being
1007 freed.
1008 </p>
1009 <div class="variablelist"><table border="0">
1010 <col align="left" valign="top">
1011 <tbody><tr>
1012 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
1013 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="NULL is ok, both for passing and for returning."><span class="acronym">allow-none</span></acronym>]</span>
1014 </td>
1015 </tr></tbody>
1016 </table></div>
1017 <p class="since">Since 2.32</p>
1018 </div>
1019 <hr>
1020 <div class="refsect2">
1021 <a name="g-bytes-unref-to-data"></a><h3>g_bytes_unref_to_data ()</h3>
1022 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_bytes_unref_to_data               (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>,
1023                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> *size</code></em>);</pre>
1024 <p>
1025 Unreferences the bytes, and returns a pointer the same byte data
1026 contents.
1027 </p>
1028 <p>
1029 As an optimization, the byte data is returned without copying if this was
1030 the last reference to bytes and bytes was created with <a class="link" href="glib-Byte-Arrays.html#g-bytes-new" title="g_bytes_new ()"><code class="function">g_bytes_new()</code></a>,
1031 <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-take" title="g_bytes_new_take ()"><code class="function">g_bytes_new_take()</code></a> or <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free-to-bytes" title="g_byte_array_free_to_bytes ()"><code class="function">g_byte_array_free_to_bytes()</code></a>. In all other cases the
1032 data is copied.
1033 </p>
1034 <div class="variablelist"><table border="0">
1035 <col align="left" valign="top">
1036 <tbody>
1037 <tr>
1038 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
1039 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1040 </td>
1041 </tr>
1042 <tr>
1043 <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
1044 <td>location to place the length of the returned data</td>
1045 </tr>
1046 <tr>
1047 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1048 <td>a pointer to the same byte data, which should
1049 be freed with <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1050 </td>
1051 </tr>
1052 </tbody>
1053 </table></div>
1054 <p class="since">Since 2.32</p>
1055 </div>
1056 <hr>
1057 <div class="refsect2">
1058 <a name="g-bytes-unref-to-array"></a><h3>g_bytes_unref_to_array ()</h3>
1059 <pre class="programlisting"><a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="returnvalue">GByteArray</span></a> *        g_bytes_unref_to_array              (<em class="parameter"><code><a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a> *bytes</code></em>);</pre>
1060 <p>
1061 Unreferences the bytes, and returns a new mutable <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> containing
1062 the same byte data.
1063 </p>
1064 <p>
1065 As an optimization, the byte data is transferred to the array without copying
1066 if this was the last reference to bytes and bytes was created with
1067 <a class="link" href="glib-Byte-Arrays.html#g-bytes-new" title="g_bytes_new ()"><code class="function">g_bytes_new()</code></a>, <a class="link" href="glib-Byte-Arrays.html#g-bytes-new-take" title="g_bytes_new_take ()"><code class="function">g_bytes_new_take()</code></a> or <a class="link" href="glib-Byte-Arrays.html#g-byte-array-free-to-bytes" title="g_byte_array_free_to_bytes ()"><code class="function">g_byte_array_free_to_bytes()</code></a>. In all
1068 other cases the data is copied.
1069 </p>
1070 <div class="variablelist"><table border="0">
1071 <col align="left" valign="top">
1072 <tbody>
1073 <tr>
1074 <td><p><span class="term"><em class="parameter"><code>bytes</code></em> :</span></p></td>
1075 <td>a <a class="link" href="glib-Byte-Arrays.html#GBytes" title="GBytes"><span class="type">GBytes</span></a>. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1076 </td>
1077 </tr>
1078 <tr>
1079 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
1080 <td>a new mutable <a class="link" href="glib-Byte-Arrays.html#GByteArray" title="struct GByteArray"><span class="type">GByteArray</span></a> containing the same byte data. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
1081 </td>
1082 </tr>
1083 </tbody>
1084 </table></div>
1085 <p class="since">Since 2.32</p>
1086 </div>
1087 </div>
1088 </div>
1089 <div class="footer">
1090 <hr>
1091           Generated by GTK-Doc V1.18</div>
1092 </body>
1093 </html>