1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module glib.Variant;
26 
27 private import glib.Bytes;
28 private import glib.ConstructionException;
29 private import glib.ErrorG;
30 private import glib.GException;
31 private import glib.Str;
32 private import glib.StringG;
33 private import glib.VariantIter;
34 private import glib.VariantType;
35 private import glib.c.functions;
36 public  import glib.c.types;
37 public  import gtkc.glibtypes;
38 private import gtkd.Loader;
39 
40 
41 /**
42  * #GVariant is a variant datatype; it can contain one or more values
43  * along with information about the type of the values.
44  * 
45  * A #GVariant may contain simple types, like an integer, or a boolean value;
46  * or complex types, like an array of two strings, or a dictionary of key
47  * value pairs. A #GVariant is also immutable: once it's been created neither
48  * its type nor its content can be modified further.
49  * 
50  * GVariant is useful whenever data needs to be serialized, for example when
51  * sending method parameters in DBus, or when saving settings using GSettings.
52  * 
53  * When creating a new #GVariant, you pass the data you want to store in it
54  * along with a string representing the type of data you wish to pass to it.
55  * 
56  * For instance, if you want to create a #GVariant holding an integer value you
57  * can use:
58  * 
59  * |[<!-- language="C" -->
60  * GVariant *v = g_variant_new ("u", 40);
61  * ]|
62  * 
63  * The string "u" in the first argument tells #GVariant that the data passed to
64  * the constructor (40) is going to be an unsigned integer.
65  * 
66  * More advanced examples of #GVariant in use can be found in documentation for
67  * [GVariant format strings][gvariant-format-strings-pointers].
68  * 
69  * The range of possible values is determined by the type.
70  * 
71  * The type system used by #GVariant is #GVariantType.
72  * 
73  * #GVariant instances always have a type and a value (which are given
74  * at construction time).  The type and value of a #GVariant instance
75  * can never change other than by the #GVariant itself being
76  * destroyed.  A #GVariant cannot contain a pointer.
77  * 
78  * #GVariant is reference counted using g_variant_ref() and
79  * g_variant_unref().  #GVariant also has floating reference counts --
80  * see g_variant_ref_sink().
81  * 
82  * #GVariant is completely threadsafe.  A #GVariant instance can be
83  * concurrently accessed in any way from any number of threads without
84  * problems.
85  * 
86  * #GVariant is heavily optimised for dealing with data in serialised
87  * form.  It works particularly well with data located in memory-mapped
88  * files.  It can perform nearly all deserialisation operations in a
89  * small constant time, usually touching only a single memory page.
90  * Serialised #GVariant data can also be sent over the network.
91  * 
92  * #GVariant is largely compatible with D-Bus.  Almost all types of
93  * #GVariant instances can be sent over D-Bus.  See #GVariantType for
94  * exceptions.  (However, #GVariant's serialisation format is not the same
95  * as the serialisation format of a D-Bus message body: use #GDBusMessage,
96  * in the gio library, for those.)
97  * 
98  * For space-efficiency, the #GVariant serialisation format does not
99  * automatically include the variant's length, type or endianness,
100  * which must either be implied from context (such as knowledge that a
101  * particular file format always contains a little-endian
102  * %G_VARIANT_TYPE_VARIANT which occupies the whole length of the file)
103  * or supplied out-of-band (for instance, a length, type and/or endianness
104  * indicator could be placed at the beginning of a file, network message
105  * or network stream).
106  * 
107  * A #GVariant's size is limited mainly by any lower level operating
108  * system constraints, such as the number of bits in #gsize.  For
109  * example, it is reasonable to have a 2GB file mapped into memory
110  * with #GMappedFile, and call g_variant_new_from_data() on it.
111  * 
112  * For convenience to C programmers, #GVariant features powerful
113  * varargs-based value construction and destruction.  This feature is
114  * designed to be embedded in other libraries.
115  * 
116  * There is a Python-inspired text language for describing #GVariant
117  * values.  #GVariant includes a printer for this language and a parser
118  * with type inferencing.
119  * 
120  * ## Memory Use
121  * 
122  * #GVariant tries to be quite efficient with respect to memory use.
123  * This section gives a rough idea of how much memory is used by the
124  * current implementation.  The information here is subject to change
125  * in the future.
126  * 
127  * The memory allocated by #GVariant can be grouped into 4 broad
128  * purposes: memory for serialised data, memory for the type
129  * information cache, buffer management memory and memory for the
130  * #GVariant structure itself.
131  * 
132  * ## Serialised Data Memory
133  * 
134  * This is the memory that is used for storing GVariant data in
135  * serialised form.  This is what would be sent over the network or
136  * what would end up on disk, not counting any indicator of the
137  * endianness, or of the length or type of the top-level variant.
138  * 
139  * The amount of memory required to store a boolean is 1 byte. 16,
140  * 32 and 64 bit integers and double precision floating point numbers
141  * use their "natural" size.  Strings (including object path and
142  * signature strings) are stored with a nul terminator, and as such
143  * use the length of the string plus 1 byte.
144  * 
145  * Maybe types use no space at all to represent the null value and
146  * use the same amount of space (sometimes plus one byte) as the
147  * equivalent non-maybe-typed value to represent the non-null case.
148  * 
149  * Arrays use the amount of space required to store each of their
150  * members, concatenated.  Additionally, if the items stored in an
151  * array are not of a fixed-size (ie: strings, other arrays, etc)
152  * then an additional framing offset is stored for each item.  The
153  * size of this offset is either 1, 2 or 4 bytes depending on the
154  * overall size of the container.  Additionally, extra padding bytes
155  * are added as required for alignment of child values.
156  * 
157  * Tuples (including dictionary entries) use the amount of space
158  * required to store each of their members, concatenated, plus one
159  * framing offset (as per arrays) for each non-fixed-sized item in
160  * the tuple, except for the last one.  Additionally, extra padding
161  * bytes are added as required for alignment of child values.
162  * 
163  * Variants use the same amount of space as the item inside of the
164  * variant, plus 1 byte, plus the length of the type string for the
165  * item inside the variant.
166  * 
167  * As an example, consider a dictionary mapping strings to variants.
168  * In the case that the dictionary is empty, 0 bytes are required for
169  * the serialisation.
170  * 
171  * If we add an item "width" that maps to the int32 value of 500 then
172  * we will use 4 byte to store the int32 (so 6 for the variant
173  * containing it) and 6 bytes for the string.  The variant must be
174  * aligned to 8 after the 6 bytes of the string, so that's 2 extra
175  * bytes.  6 (string) + 2 (padding) + 6 (variant) is 14 bytes used
176  * for the dictionary entry.  An additional 1 byte is added to the
177  * array as a framing offset making a total of 15 bytes.
178  * 
179  * If we add another entry, "title" that maps to a nullable string
180  * that happens to have a value of null, then we use 0 bytes for the
181  * null value (and 3 bytes for the variant to contain it along with
182  * its type string) plus 6 bytes for the string.  Again, we need 2
183  * padding bytes.  That makes a total of 6 + 2 + 3 = 11 bytes.
184  * 
185  * We now require extra padding between the two items in the array.
186  * After the 14 bytes of the first item, that's 2 bytes required.
187  * We now require 2 framing offsets for an extra two
188  * bytes. 14 + 2 + 11 + 2 = 29 bytes to encode the entire two-item
189  * dictionary.
190  * 
191  * ## Type Information Cache
192  * 
193  * For each GVariant type that currently exists in the program a type
194  * information structure is kept in the type information cache.  The
195  * type information structure is required for rapid deserialisation.
196  * 
197  * Continuing with the above example, if a #GVariant exists with the
198  * type "a{sv}" then a type information struct will exist for
199  * "a{sv}", "{sv}", "s", and "v".  Multiple uses of the same type
200  * will share the same type information.  Additionally, all
201  * single-digit types are stored in read-only static memory and do
202  * not contribute to the writable memory footprint of a program using
203  * #GVariant.
204  * 
205  * Aside from the type information structures stored in read-only
206  * memory, there are two forms of type information.  One is used for
207  * container types where there is a single element type: arrays and
208  * maybe types.  The other is used for container types where there
209  * are multiple element types: tuples and dictionary entries.
210  * 
211  * Array type info structures are 6 * sizeof (void *), plus the
212  * memory required to store the type string itself.  This means that
213  * on 32-bit systems, the cache entry for "a{sv}" would require 30
214  * bytes of memory (plus malloc overhead).
215  * 
216  * Tuple type info structures are 6 * sizeof (void *), plus 4 *
217  * sizeof (void *) for each item in the tuple, plus the memory
218  * required to store the type string itself.  A 2-item tuple, for
219  * example, would have a type information structure that consumed
220  * writable memory in the size of 14 * sizeof (void *) (plus type
221  * string)  This means that on 32-bit systems, the cache entry for
222  * "{sv}" would require 61 bytes of memory (plus malloc overhead).
223  * 
224  * This means that in total, for our "a{sv}" example, 91 bytes of
225  * type information would be allocated.
226  * 
227  * The type information cache, additionally, uses a #GHashTable to
228  * store and lookup the cached items and stores a pointer to this
229  * hash table in static storage.  The hash table is freed when there
230  * are zero items in the type cache.
231  * 
232  * Although these sizes may seem large it is important to remember
233  * that a program will probably only have a very small number of
234  * different types of values in it and that only one type information
235  * structure is required for many different values of the same type.
236  * 
237  * ## Buffer Management Memory
238  * 
239  * #GVariant uses an internal buffer management structure to deal
240  * with the various different possible sources of serialised data
241  * that it uses.  The buffer is responsible for ensuring that the
242  * correct call is made when the data is no longer in use by
243  * #GVariant.  This may involve a g_free() or a g_slice_free() or
244  * even g_mapped_file_unref().
245  * 
246  * One buffer management structure is used for each chunk of
247  * serialised data.  The size of the buffer management structure
248  * is 4 * (void *).  On 32-bit systems, that's 16 bytes.
249  * 
250  * ## GVariant structure
251  * 
252  * The size of a #GVariant structure is 6 * (void *).  On 32-bit
253  * systems, that's 24 bytes.
254  * 
255  * #GVariant structures only exist if they are explicitly created
256  * with API calls.  For example, if a #GVariant is constructed out of
257  * serialised data for the example given above (with the dictionary)
258  * then although there are 9 individual values that comprise the
259  * entire dictionary (two keys, two values, two variants containing
260  * the values, two dictionary entries, plus the dictionary itself),
261  * only 1 #GVariant instance exists -- the one referring to the
262  * dictionary.
263  * 
264  * If calls are made to start accessing the other values then
265  * #GVariant instances will exist for those values only for as long
266  * as they are in use (ie: until you call g_variant_unref()).  The
267  * type information is shared.  The serialised data and the buffer
268  * management structure for that serialised data is shared by the
269  * child.
270  * 
271  * ## Summary
272  * 
273  * To put the entire example together, for our dictionary mapping
274  * strings to variants (with two entries, as given above), we are
275  * using 91 bytes of memory for type information, 29 bytes of memory
276  * for the serialised data, 16 bytes for buffer management and 24
277  * bytes for the #GVariant instance, or a total of 160 bytes, plus
278  * malloc overhead.  If we were to use g_variant_get_child_value() to
279  * access the two dictionary entries, we would use an additional 48
280  * bytes.  If we were to have other dictionaries of the same type, we
281  * would use more memory for the serialised data and buffer
282  * management for those dictionaries, but the type information would
283  * be shared.
284  *
285  * Since: 2.24
286  */
287 public class Variant
288 {
289 	/** the main Gtk struct */
290 	protected GVariant* gVariant;
291 	protected bool ownedRef;
292 
293 	/** Get the main Gtk struct */
294 	public GVariant* getVariantStruct(bool transferOwnership = false)
295 	{
296 		if (transferOwnership)
297 			ownedRef = false;
298 		return gVariant;
299 	}
300 
301 	/** the main Gtk struct as a void* */
302 	protected void* getStruct()
303 	{
304 		return cast(void*)gVariant;
305 	}
306 
307 	/**
308 	 * Sets our main struct and passes it to the parent class.
309 	 */
310 	public this (GVariant* gVariant, bool ownedRef = false)
311 	{
312 		this.gVariant = gVariant;
313 		this.ownedRef = ownedRef;
314 	}
315 
316 	~this ()
317 	{
318 		if ( Linker.isLoaded(LIBRARY_GLIB) && ownedRef )
319 			g_variant_unref(gVariant);
320 	}
321 
322 	/**
323 	 * Creates a DBus object path GVariant with the contents of string.
324 	 * string must be a valid DBus object path.
325 	 * Use Variant.isObjectPath() if you're not sure.
326 	 *
327 	 * Since: 2.24
328 	 *
329 	 * Throws: ConstructionException GTK+ fails to create the object.
330 	 */
331 	public static Variant fromObjectPath(string path)
332 	{
333 		auto p = g_variant_new_object_path(Str.toStringz(path));
334 		if(p is null)
335 		{
336 			throw new ConstructionException("null returned by g_variant_new_object_path");
337 		}
338 		return new Variant(cast(GVariant*) p);
339 	}
340 
341 	/**
342 	 * Creates a DBus type signature GVariant with the contents of string.
343 	 * string must be a valid DBus type signature.
344 	 * Use Variant.isSignature() if you're not sure.
345 	 *
346 	 * Since: 2.24
347 	 *
348 	 * Throws: ConstructionException GTK+ fails to create the object.
349 	 */
350 	public static Variant fromSignature(string signature)
351 	{
352 		auto p = g_variant_new_signature(Str.toStringz(signature));
353 		if(p is null)
354 		{
355 			throw new ConstructionException("null returned by g_variant_new_signature");
356 		}
357 		return new Variant(cast(GVariant*) p);
358 	}
359 
360 	/**
361 	 * Creates an array-of-bytes GVariant with the contents of string.
362 	 * This function is just like new Variant(string) except that the string
363 	 * need not be valid utf8.
364 	 *
365 	 * The nul terminator character at the end of the string is stored in
366 	 * the array.
367 	 *
368 	 * Throws: ConstructionException GTK+ fails to create the object.
369 	 */
370 	public static Variant fromByteString(string byteString)
371 	{
372 		auto p = g_variant_new_bytestring(Str.toStringz(byteString));
373 		if(p is null)
374 		{
375 			throw new ConstructionException("null returned by g_variant_new_bytestring");
376 		}
377 		return new Variant(cast(GVariant*) p);
378 	}
379 
380 	/**
381 	 * Constructs an array of object paths Variant from the given array
382 	 * of strings.
383 	 *
384 	 * Each string must be a valid Variant object path.
385 	 *
386 	 * Since: 2.30
387 	 *
388 	 * Params:
389 	 *     strv   = an array of strings.
390 	 *
391 	 * Throws: ConstructionException GTK+ fails to create the object.
392 	 */
393 	public static Variant fromObjv(string[] strv)
394 	{
395 		// GVariant * g_variant_new_objv (const gchar * const *strv,  gssize length);
396 		auto p = g_variant_new_objv(Str.toStringzArray(strv), strv.length);
397 		if(p is null)
398 		{
399 			throw new ConstructionException("null returned by g_variant_new_objv(strv, length)");
400 		}
401 		return new Variant(cast(GVariant*) p);
402 	}
403 
404 	/**
405 	 * Constructs an array of bytestring GVariant from the given array of
406 	 * strings. If length is -1 then strv is null-terminated.
407 	 *
408 	 * Since: 2.26
409 	 *
410 	 * Params:
411 	 *     strv   = an array of strings.
412 	 *
413 	 * Throws: ConstructionException GTK+ fails to create the object.
414 	 */
415 	public static Variant fromByteStringArray(string[] strv)
416 	{
417 		auto p = g_variant_new_bytestring_array(Str.toStringzArray(strv), strv.length);
418 		if(p is null)
419 		{
420 			throw new ConstructionException("null returned by g_variant_new_bytestring_array(strv, length)");
421 		}
422 		return new Variant(cast(GVariant*) p);
423 	}
424 
425 	/**
426 	 */
427 
428 	/**
429 	 * Creates a new #GVariant array from @children.
430 	 *
431 	 * @child_type must be non-%NULL if @n_children is zero.  Otherwise, the
432 	 * child type is determined by inspecting the first element of the
433 	 * @children array.  If @child_type is non-%NULL then it must be a
434 	 * definite type.
435 	 *
436 	 * The items of the array are taken from the @children array.  No entry
437 	 * in the @children array may be %NULL.
438 	 *
439 	 * All items in the array must have the same type, which must be the
440 	 * same as @child_type, if given.
441 	 *
442 	 * If the @children are floating references (see g_variant_ref_sink()), the
443 	 * new instance takes ownership of them as if via g_variant_ref_sink().
444 	 *
445 	 * Params:
446 	 *     childType = the element type of the new array
447 	 *     children = an array of
448 	 *         #GVariant pointers, the children
449 	 *
450 	 * Returns: a floating reference to a new #GVariant array
451 	 *
452 	 * Since: 2.24
453 	 *
454 	 * Throws: ConstructionException GTK+ fails to create the object.
455 	 */
456 	public this(VariantType childType, Variant[] children)
457 	{
458 		GVariant*[] childrenArray = new GVariant*[children.length];
459 		for ( int i = 0; i < children.length; i++ )
460 		{
461 			childrenArray[i] = children[i].getVariantStruct();
462 		}
463 
464 		auto p = g_variant_new_array((childType is null) ? null : childType.getVariantTypeStruct(), childrenArray.ptr, cast(size_t)children.length);
465 
466 		if(p is null)
467 		{
468 			throw new ConstructionException("null returned by new_array");
469 		}
470 
471 		this(cast(GVariant*) p);
472 	}
473 
474 	/**
475 	 * Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
476 	 *
477 	 * Params:
478 	 *     value = a #gboolean value
479 	 *
480 	 * Returns: a floating reference to a new boolean #GVariant instance
481 	 *
482 	 * Since: 2.24
483 	 *
484 	 * Throws: ConstructionException GTK+ fails to create the object.
485 	 */
486 	public this(bool value)
487 	{
488 		auto p = g_variant_new_boolean(value);
489 
490 		if(p is null)
491 		{
492 			throw new ConstructionException("null returned by new_boolean");
493 		}
494 
495 		this(cast(GVariant*) p);
496 	}
497 
498 	/**
499 	 * Creates a new byte #GVariant instance.
500 	 *
501 	 * Params:
502 	 *     value = a #guint8 value
503 	 *
504 	 * Returns: a floating reference to a new byte #GVariant instance
505 	 *
506 	 * Since: 2.24
507 	 *
508 	 * Throws: ConstructionException GTK+ fails to create the object.
509 	 */
510 	public this(char value)
511 	{
512 		auto p = g_variant_new_byte(value);
513 
514 		if(p is null)
515 		{
516 			throw new ConstructionException("null returned by new_byte");
517 		}
518 
519 		this(cast(GVariant*) p);
520 	}
521 
522 	/**
523 	 * Creates a new dictionary entry #GVariant. @key and @value must be
524 	 * non-%NULL. @key must be a value of a basic type (ie: not a container).
525 	 *
526 	 * If the @key or @value are floating references (see g_variant_ref_sink()),
527 	 * the new instance takes ownership of them as if via g_variant_ref_sink().
528 	 *
529 	 * Params:
530 	 *     key = a basic #GVariant, the key
531 	 *     value = a #GVariant, the value
532 	 *
533 	 * Returns: a floating reference to a new dictionary entry #GVariant
534 	 *
535 	 * Since: 2.24
536 	 *
537 	 * Throws: ConstructionException GTK+ fails to create the object.
538 	 */
539 	public this(Variant key, Variant value)
540 	{
541 		auto p = g_variant_new_dict_entry((key is null) ? null : key.getVariantStruct(), (value is null) ? null : value.getVariantStruct());
542 
543 		if(p is null)
544 		{
545 			throw new ConstructionException("null returned by new_dict_entry");
546 		}
547 
548 		this(cast(GVariant*) p);
549 	}
550 
551 	/**
552 	 * Creates a new double #GVariant instance.
553 	 *
554 	 * Params:
555 	 *     value = a #gdouble floating point value
556 	 *
557 	 * Returns: a floating reference to a new double #GVariant instance
558 	 *
559 	 * Since: 2.24
560 	 *
561 	 * Throws: ConstructionException GTK+ fails to create the object.
562 	 */
563 	public this(double value)
564 	{
565 		auto p = g_variant_new_double(value);
566 
567 		if(p is null)
568 		{
569 			throw new ConstructionException("null returned by new_double");
570 		}
571 
572 		this(cast(GVariant*) p);
573 	}
574 
575 	/**
576 	 * Constructs a new array #GVariant instance, where the elements are
577 	 * of @element_type type.
578 	 *
579 	 * @elements must be an array with fixed-sized elements.  Numeric types are
580 	 * fixed-size as are tuples containing only other fixed-sized types.
581 	 *
582 	 * @element_size must be the size of a single element in the array.
583 	 * For example, if calling this function for an array of 32-bit integers,
584 	 * you might say sizeof(gint32). This value isn't used except for the purpose
585 	 * of a double-check that the form of the serialised data matches the caller's
586 	 * expectation.
587 	 *
588 	 * @n_elements must be the length of the @elements array.
589 	 *
590 	 * Params:
591 	 *     elementType = the #GVariantType of each element
592 	 *     elements = a pointer to the fixed array of contiguous elements
593 	 *     nElements = the number of elements
594 	 *     elementSize = the size of each element
595 	 *
596 	 * Returns: a floating reference to a new array #GVariant instance
597 	 *
598 	 * Since: 2.32
599 	 *
600 	 * Throws: ConstructionException GTK+ fails to create the object.
601 	 */
602 	public this(VariantType elementType, void* elements, size_t nElements, size_t elementSize)
603 	{
604 		auto p = g_variant_new_fixed_array((elementType is null) ? null : elementType.getVariantTypeStruct(), elements, nElements, elementSize);
605 
606 		if(p is null)
607 		{
608 			throw new ConstructionException("null returned by new_fixed_array");
609 		}
610 
611 		this(cast(GVariant*) p);
612 	}
613 
614 	/**
615 	 * Constructs a new serialised-mode #GVariant instance.  This is the
616 	 * inner interface for creation of new serialised values that gets
617 	 * called from various functions in gvariant.c.
618 	 *
619 	 * A reference is taken on @bytes.
620 	 *
621 	 * Params:
622 	 *     type = a #GVariantType
623 	 *     bytes = a #GBytes
624 	 *     trusted = if the contents of @bytes are trusted
625 	 *
626 	 * Returns: a new #GVariant with a floating reference
627 	 *
628 	 * Since: 2.36
629 	 *
630 	 * Throws: ConstructionException GTK+ fails to create the object.
631 	 */
632 	public this(VariantType type, Bytes bytes, bool trusted)
633 	{
634 		auto p = g_variant_new_from_bytes((type is null) ? null : type.getVariantTypeStruct(), (bytes is null) ? null : bytes.getBytesStruct(), trusted);
635 
636 		if(p is null)
637 		{
638 			throw new ConstructionException("null returned by new_from_bytes");
639 		}
640 
641 		this(cast(GVariant*) p);
642 	}
643 
644 	/**
645 	 * Creates a new #GVariant instance from serialised data.
646 	 *
647 	 * @type is the type of #GVariant instance that will be constructed.
648 	 * The interpretation of @data depends on knowing the type.
649 	 *
650 	 * @data is not modified by this function and must remain valid with an
651 	 * unchanging value until such a time as @notify is called with
652 	 * @user_data.  If the contents of @data change before that time then
653 	 * the result is undefined.
654 	 *
655 	 * If @data is trusted to be serialised data in normal form then
656 	 * @trusted should be %TRUE.  This applies to serialised data created
657 	 * within this process or read from a trusted location on the disk (such
658 	 * as a file installed in /usr/lib alongside your application).  You
659 	 * should set trusted to %FALSE if @data is read from the network, a
660 	 * file in the user's home directory, etc.
661 	 *
662 	 * If @data was not stored in this machine's native endianness, any multi-byte
663 	 * numeric values in the returned variant will also be in non-native
664 	 * endianness. g_variant_byteswap() can be used to recover the original values.
665 	 *
666 	 * @notify will be called with @user_data when @data is no longer
667 	 * needed.  The exact time of this call is unspecified and might even be
668 	 * before this function returns.
669 	 *
670 	 * Params:
671 	 *     type = a definite #GVariantType
672 	 *     data = the serialised data
673 	 *     trusted = %TRUE if @data is definitely in normal form
674 	 *     notify = function to call when @data is no longer needed
675 	 *     userData = data for @notify
676 	 *
677 	 * Returns: a new floating #GVariant of type @type
678 	 *
679 	 * Since: 2.24
680 	 *
681 	 * Throws: ConstructionException GTK+ fails to create the object.
682 	 */
683 	public this(VariantType type, ubyte[] data, bool trusted, GDestroyNotify notify, void* userData)
684 	{
685 		auto p = g_variant_new_from_data((type is null) ? null : type.getVariantTypeStruct(), data.ptr, cast(size_t)data.length, trusted, notify, userData);
686 
687 		if(p is null)
688 		{
689 			throw new ConstructionException("null returned by new_from_data");
690 		}
691 
692 		this(cast(GVariant*) p);
693 	}
694 
695 	/**
696 	 * Creates a new int16 #GVariant instance.
697 	 *
698 	 * Params:
699 	 *     value = a #gint16 value
700 	 *
701 	 * Returns: a floating reference to a new int16 #GVariant instance
702 	 *
703 	 * Since: 2.24
704 	 *
705 	 * Throws: ConstructionException GTK+ fails to create the object.
706 	 */
707 	public this(short value)
708 	{
709 		auto p = g_variant_new_int16(value);
710 
711 		if(p is null)
712 		{
713 			throw new ConstructionException("null returned by new_int16");
714 		}
715 
716 		this(cast(GVariant*) p);
717 	}
718 
719 	/**
720 	 * Creates a new int32 #GVariant instance.
721 	 *
722 	 * Params:
723 	 *     value = a #gint32 value
724 	 *
725 	 * Returns: a floating reference to a new int32 #GVariant instance
726 	 *
727 	 * Since: 2.24
728 	 *
729 	 * Throws: ConstructionException GTK+ fails to create the object.
730 	 */
731 	public this(int value)
732 	{
733 		auto p = g_variant_new_int32(value);
734 
735 		if(p is null)
736 		{
737 			throw new ConstructionException("null returned by new_int32");
738 		}
739 
740 		this(cast(GVariant*) p);
741 	}
742 
743 	/**
744 	 * Creates a new int64 #GVariant instance.
745 	 *
746 	 * Params:
747 	 *     value = a #gint64 value
748 	 *
749 	 * Returns: a floating reference to a new int64 #GVariant instance
750 	 *
751 	 * Since: 2.24
752 	 *
753 	 * Throws: ConstructionException GTK+ fails to create the object.
754 	 */
755 	public this(long value)
756 	{
757 		auto p = g_variant_new_int64(value);
758 
759 		if(p is null)
760 		{
761 			throw new ConstructionException("null returned by new_int64");
762 		}
763 
764 		this(cast(GVariant*) p);
765 	}
766 
767 	/**
768 	 * Depending on if @child is %NULL, either wraps @child inside of a
769 	 * maybe container or creates a Nothing instance for the given @type.
770 	 *
771 	 * At least one of @child_type and @child must be non-%NULL.
772 	 * If @child_type is non-%NULL then it must be a definite type.
773 	 * If they are both non-%NULL then @child_type must be the type
774 	 * of @child.
775 	 *
776 	 * If @child is a floating reference (see g_variant_ref_sink()), the new
777 	 * instance takes ownership of @child.
778 	 *
779 	 * Params:
780 	 *     childType = the #GVariantType of the child, or %NULL
781 	 *     child = the child value, or %NULL
782 	 *
783 	 * Returns: a floating reference to a new #GVariant maybe instance
784 	 *
785 	 * Since: 2.24
786 	 *
787 	 * Throws: ConstructionException GTK+ fails to create the object.
788 	 */
789 	public this(VariantType childType, Variant child)
790 	{
791 		auto p = g_variant_new_maybe((childType is null) ? null : childType.getVariantTypeStruct(), (child is null) ? null : child.getVariantStruct());
792 
793 		if(p is null)
794 		{
795 			throw new ConstructionException("null returned by new_maybe");
796 		}
797 
798 		this(cast(GVariant*) p);
799 	}
800 
801 	/**
802 	 * Parses @format and returns the result.
803 	 *
804 	 * This is the version of g_variant_new_parsed() intended to be used
805 	 * from libraries.
806 	 *
807 	 * The return value will be floating if it was a newly created GVariant
808 	 * instance.  In the case that @format simply specified the collection
809 	 * of a #GVariant pointer (eg: @format was "%*") then the collected
810 	 * #GVariant pointer will be returned unmodified, without adding any
811 	 * additional references.
812 	 *
813 	 * Note that the arguments in @app must be of the correct width for their types
814 	 * specified in @format when collected into the #va_list. See
815 	 * the [GVariant varargs documentation][gvariant-varargs].
816 	 *
817 	 * In order to behave correctly in all cases it is necessary for the
818 	 * calling function to g_variant_ref_sink() the return result before
819 	 * returning control to the user that originally provided the pointer.
820 	 * At this point, the caller will have their own full reference to the
821 	 * result.  This can also be done by adding the result to a container,
822 	 * or by passing it to another g_variant_new() call.
823 	 *
824 	 * Params:
825 	 *     format = a text format #GVariant
826 	 *     app = a pointer to a #va_list
827 	 *
828 	 * Returns: a new, usually floating, #GVariant
829 	 *
830 	 * Throws: ConstructionException GTK+ fails to create the object.
831 	 */
832 	public this(string format, void** app)
833 	{
834 		auto p = g_variant_new_parsed_va(Str.toStringz(format), app);
835 
836 		if(p is null)
837 		{
838 			throw new ConstructionException("null returned by new_parsed_va");
839 		}
840 
841 		this(cast(GVariant*) p);
842 	}
843 
844 	/**
845 	 * Creates a string #GVariant with the contents of @string.
846 	 *
847 	 * @string must be valid UTF-8, and must not be %NULL. To encode
848 	 * potentially-%NULL strings, use g_variant_new() with `ms` as the
849 	 * [format string][gvariant-format-strings-maybe-types].
850 	 *
851 	 * Params:
852 	 *     string_ = a normal UTF-8 nul-terminated string
853 	 *
854 	 * Returns: a floating reference to a new string #GVariant instance
855 	 *
856 	 * Since: 2.24
857 	 *
858 	 * Throws: ConstructionException GTK+ fails to create the object.
859 	 */
860 	public this(string string_)
861 	{
862 		auto p = g_variant_new_string(Str.toStringz(string_));
863 
864 		if(p is null)
865 		{
866 			throw new ConstructionException("null returned by new_string");
867 		}
868 
869 		this(cast(GVariant*) p);
870 	}
871 
872 	/**
873 	 * Constructs an array of strings #GVariant from the given array of
874 	 * strings.
875 	 *
876 	 * If @length is -1 then @strv is %NULL-terminated.
877 	 *
878 	 * Params:
879 	 *     strv = an array of strings
880 	 *
881 	 * Returns: a new floating #GVariant instance
882 	 *
883 	 * Since: 2.24
884 	 *
885 	 * Throws: ConstructionException GTK+ fails to create the object.
886 	 */
887 	public this(string[] strv)
888 	{
889 		auto p = g_variant_new_strv(Str.toStringzArray(strv), cast(ptrdiff_t)strv.length);
890 
891 		if(p is null)
892 		{
893 			throw new ConstructionException("null returned by new_strv");
894 		}
895 
896 		this(cast(GVariant*) p);
897 	}
898 
899 	/**
900 	 * Creates a new tuple #GVariant out of the items in @children.  The
901 	 * type is determined from the types of @children.  No entry in the
902 	 * @children array may be %NULL.
903 	 *
904 	 * If @n_children is 0 then the unit tuple is constructed.
905 	 *
906 	 * If the @children are floating references (see g_variant_ref_sink()), the
907 	 * new instance takes ownership of them as if via g_variant_ref_sink().
908 	 *
909 	 * Params:
910 	 *     children = the items to make the tuple out of
911 	 *
912 	 * Returns: a floating reference to a new #GVariant tuple
913 	 *
914 	 * Since: 2.24
915 	 *
916 	 * Throws: ConstructionException GTK+ fails to create the object.
917 	 */
918 	public this(Variant[] children)
919 	{
920 		GVariant*[] childrenArray = new GVariant*[children.length];
921 		for ( int i = 0; i < children.length; i++ )
922 		{
923 			childrenArray[i] = children[i].getVariantStruct();
924 		}
925 
926 		auto p = g_variant_new_tuple(childrenArray.ptr, cast(size_t)children.length);
927 
928 		if(p is null)
929 		{
930 			throw new ConstructionException("null returned by new_tuple");
931 		}
932 
933 		this(cast(GVariant*) p);
934 	}
935 
936 	/**
937 	 * Creates a new uint16 #GVariant instance.
938 	 *
939 	 * Params:
940 	 *     value = a #guint16 value
941 	 *
942 	 * Returns: a floating reference to a new uint16 #GVariant instance
943 	 *
944 	 * Since: 2.24
945 	 *
946 	 * Throws: ConstructionException GTK+ fails to create the object.
947 	 */
948 	public this(ushort value)
949 	{
950 		auto p = g_variant_new_uint16(value);
951 
952 		if(p is null)
953 		{
954 			throw new ConstructionException("null returned by new_uint16");
955 		}
956 
957 		this(cast(GVariant*) p);
958 	}
959 
960 	/**
961 	 * Creates a new uint32 #GVariant instance.
962 	 *
963 	 * Params:
964 	 *     value = a #guint32 value
965 	 *
966 	 * Returns: a floating reference to a new uint32 #GVariant instance
967 	 *
968 	 * Since: 2.24
969 	 *
970 	 * Throws: ConstructionException GTK+ fails to create the object.
971 	 */
972 	public this(uint value)
973 	{
974 		auto p = g_variant_new_uint32(value);
975 
976 		if(p is null)
977 		{
978 			throw new ConstructionException("null returned by new_uint32");
979 		}
980 
981 		this(cast(GVariant*) p);
982 	}
983 
984 	/**
985 	 * Creates a new uint64 #GVariant instance.
986 	 *
987 	 * Params:
988 	 *     value = a #guint64 value
989 	 *
990 	 * Returns: a floating reference to a new uint64 #GVariant instance
991 	 *
992 	 * Since: 2.24
993 	 *
994 	 * Throws: ConstructionException GTK+ fails to create the object.
995 	 */
996 	public this(ulong value)
997 	{
998 		auto p = g_variant_new_uint64(value);
999 
1000 		if(p is null)
1001 		{
1002 			throw new ConstructionException("null returned by new_uint64");
1003 		}
1004 
1005 		this(cast(GVariant*) p);
1006 	}
1007 
1008 	/**
1009 	 * This function is intended to be used by libraries based on
1010 	 * #GVariant that want to provide g_variant_new()-like functionality
1011 	 * to their users.
1012 	 *
1013 	 * The API is more general than g_variant_new() to allow a wider range
1014 	 * of possible uses.
1015 	 *
1016 	 * @format_string must still point to a valid format string, but it only
1017 	 * needs to be nul-terminated if @endptr is %NULL.  If @endptr is
1018 	 * non-%NULL then it is updated to point to the first character past the
1019 	 * end of the format string.
1020 	 *
1021 	 * @app is a pointer to a #va_list.  The arguments, according to
1022 	 * @format_string, are collected from this #va_list and the list is left
1023 	 * pointing to the argument following the last.
1024 	 *
1025 	 * Note that the arguments in @app must be of the correct width for their
1026 	 * types specified in @format_string when collected into the #va_list.
1027 	 * See the [GVariant varargs documentation][gvariant-varargs].
1028 	 *
1029 	 * These two generalisations allow mixing of multiple calls to
1030 	 * g_variant_new_va() and g_variant_get_va() within a single actual
1031 	 * varargs call by the user.
1032 	 *
1033 	 * The return value will be floating if it was a newly created GVariant
1034 	 * instance (for example, if the format string was "(ii)").  In the case
1035 	 * that the format_string was '*', '?', 'r', or a format starting with
1036 	 * '@' then the collected #GVariant pointer will be returned unmodified,
1037 	 * without adding any additional references.
1038 	 *
1039 	 * In order to behave correctly in all cases it is necessary for the
1040 	 * calling function to g_variant_ref_sink() the return result before
1041 	 * returning control to the user that originally provided the pointer.
1042 	 * At this point, the caller will have their own full reference to the
1043 	 * result.  This can also be done by adding the result to a container,
1044 	 * or by passing it to another g_variant_new() call.
1045 	 *
1046 	 * Params:
1047 	 *     formatString = a string that is prefixed with a format string
1048 	 *     endptr = location to store the end pointer,
1049 	 *         or %NULL
1050 	 *     app = a pointer to a #va_list
1051 	 *
1052 	 * Returns: a new, usually floating, #GVariant
1053 	 *
1054 	 * Since: 2.24
1055 	 *
1056 	 * Throws: ConstructionException GTK+ fails to create the object.
1057 	 */
1058 	public this(string formatString, string[] endptr, void** app)
1059 	{
1060 		auto p = g_variant_new_va(Str.toStringz(formatString), Str.toStringzArray(endptr), app);
1061 
1062 		if(p is null)
1063 		{
1064 			throw new ConstructionException("null returned by new_va");
1065 		}
1066 
1067 		this(cast(GVariant*) p);
1068 	}
1069 
1070 	/**
1071 	 * Boxes @value.  The result is a #GVariant instance representing a
1072 	 * variant containing the original value.
1073 	 *
1074 	 * If @child is a floating reference (see g_variant_ref_sink()), the new
1075 	 * instance takes ownership of @child.
1076 	 *
1077 	 * Params:
1078 	 *     value = a #GVariant instance
1079 	 *
1080 	 * Returns: a floating reference to a new variant #GVariant instance
1081 	 *
1082 	 * Since: 2.24
1083 	 *
1084 	 * Throws: ConstructionException GTK+ fails to create the object.
1085 	 */
1086 	public this(Variant value)
1087 	{
1088 		auto p = g_variant_new_variant((value is null) ? null : value.getVariantStruct());
1089 
1090 		if(p is null)
1091 		{
1092 			throw new ConstructionException("null returned by new_variant");
1093 		}
1094 
1095 		this(cast(GVariant*) p);
1096 	}
1097 
1098 	/**
1099 	 * Performs a byteswapping operation on the contents of @value.  The
1100 	 * result is that all multi-byte numeric data contained in @value is
1101 	 * byteswapped.  That includes 16, 32, and 64bit signed and unsigned
1102 	 * integers as well as file handles and double precision floating point
1103 	 * values.
1104 	 *
1105 	 * This function is an identity mapping on any value that does not
1106 	 * contain multi-byte numeric data.  That include strings, booleans,
1107 	 * bytes and containers containing only these things (recursively).
1108 	 *
1109 	 * The returned value is always in normal form and is marked as trusted.
1110 	 *
1111 	 * Returns: the byteswapped form of @value
1112 	 *
1113 	 * Since: 2.24
1114 	 */
1115 	public Variant byteswap()
1116 	{
1117 		auto p = g_variant_byteswap(gVariant);
1118 
1119 		if(p is null)
1120 		{
1121 			return null;
1122 		}
1123 
1124 		return new Variant(cast(GVariant*) p, true);
1125 	}
1126 
1127 	/**
1128 	 * Checks if calling g_variant_get() with @format_string on @value would
1129 	 * be valid from a type-compatibility standpoint.  @format_string is
1130 	 * assumed to be a valid format string (from a syntactic standpoint).
1131 	 *
1132 	 * If @copy_only is %TRUE then this function additionally checks that it
1133 	 * would be safe to call g_variant_unref() on @value immediately after
1134 	 * the call to g_variant_get() without invalidating the result.  This is
1135 	 * only possible if deep copies are made (ie: there are no pointers to
1136 	 * the data inside of the soon-to-be-freed #GVariant instance).  If this
1137 	 * check fails then a g_critical() is printed and %FALSE is returned.
1138 	 *
1139 	 * This function is meant to be used by functions that wish to provide
1140 	 * varargs accessors to #GVariant values of uncertain values (eg:
1141 	 * g_variant_lookup() or g_menu_model_get_item_attribute()).
1142 	 *
1143 	 * Params:
1144 	 *     formatString = a valid #GVariant format string
1145 	 *     copyOnly = %TRUE to ensure the format string makes deep copies
1146 	 *
1147 	 * Returns: %TRUE if @format_string is safe to use
1148 	 *
1149 	 * Since: 2.34
1150 	 */
1151 	public bool checkFormatString(string formatString, bool copyOnly)
1152 	{
1153 		return g_variant_check_format_string(gVariant, Str.toStringz(formatString), copyOnly) != 0;
1154 	}
1155 
1156 	/**
1157 	 * Classifies @value according to its top-level type.
1158 	 *
1159 	 * Returns: the #GVariantClass of @value
1160 	 *
1161 	 * Since: 2.24
1162 	 */
1163 	public GVariantClass classify()
1164 	{
1165 		return g_variant_classify(gVariant);
1166 	}
1167 
1168 	/**
1169 	 * Compares @one and @two.
1170 	 *
1171 	 * The types of @one and @two are #gconstpointer only to allow use of
1172 	 * this function with #GTree, #GPtrArray, etc.  They must each be a
1173 	 * #GVariant.
1174 	 *
1175 	 * Comparison is only defined for basic types (ie: booleans, numbers,
1176 	 * strings).  For booleans, %FALSE is less than %TRUE.  Numbers are
1177 	 * ordered in the usual way.  Strings are in ASCII lexographical order.
1178 	 *
1179 	 * It is a programmer error to attempt to compare container values or
1180 	 * two values that have types that are not exactly equal.  For example,
1181 	 * you cannot compare a 32-bit signed integer with a 32-bit unsigned
1182 	 * integer.  Also note that this function is not particularly
1183 	 * well-behaved when it comes to comparison of doubles; in particular,
1184 	 * the handling of incomparable values (ie: NaN) is undefined.
1185 	 *
1186 	 * If you only require an equality comparison, g_variant_equal() is more
1187 	 * general.
1188 	 *
1189 	 * Params:
1190 	 *     two = a #GVariant instance of the same type
1191 	 *
1192 	 * Returns: negative value if a < b;
1193 	 *     zero if a = b;
1194 	 *     positive value if a > b.
1195 	 *
1196 	 * Since: 2.26
1197 	 */
1198 	public int compare(Variant two)
1199 	{
1200 		return g_variant_compare(gVariant, (two is null) ? null : two.getVariantStruct());
1201 	}
1202 
1203 	/**
1204 	 * Similar to g_variant_get_bytestring() except that instead of
1205 	 * returning a constant string, the string is duplicated.
1206 	 *
1207 	 * The return value must be freed using g_free().
1208 	 *
1209 	 * Returns: a newly allocated string
1210 	 *
1211 	 * Since: 2.26
1212 	 */
1213 	public string dupBytestring()
1214 	{
1215 		size_t length;
1216 
1217 		auto retStr = g_variant_dup_bytestring(gVariant, &length);
1218 
1219 		scope(exit) Str.freeString(retStr);
1220 		return Str.toString(retStr, length);
1221 	}
1222 
1223 	/**
1224 	 * Gets the contents of an array of array of bytes #GVariant.  This call
1225 	 * makes a deep copy; the return result should be released with
1226 	 * g_strfreev().
1227 	 *
1228 	 * If @length is non-%NULL then the number of elements in the result is
1229 	 * stored there.  In any case, the resulting array will be
1230 	 * %NULL-terminated.
1231 	 *
1232 	 * For an empty array, @length will be set to 0 and a pointer to a
1233 	 * %NULL pointer will be returned.
1234 	 *
1235 	 * Returns: an array of strings
1236 	 *
1237 	 * Since: 2.26
1238 	 */
1239 	public string[] dupBytestringArray()
1240 	{
1241 		size_t length;
1242 
1243 		auto retStr = g_variant_dup_bytestring_array(gVariant, &length);
1244 
1245 		scope(exit) Str.freeStringArray(retStr);
1246 		return Str.toStringArray(retStr, length);
1247 	}
1248 
1249 	/**
1250 	 * Gets the contents of an array of object paths #GVariant.  This call
1251 	 * makes a deep copy; the return result should be released with
1252 	 * g_strfreev().
1253 	 *
1254 	 * If @length is non-%NULL then the number of elements in the result
1255 	 * is stored there.  In any case, the resulting array will be
1256 	 * %NULL-terminated.
1257 	 *
1258 	 * For an empty array, @length will be set to 0 and a pointer to a
1259 	 * %NULL pointer will be returned.
1260 	 *
1261 	 * Returns: an array of strings
1262 	 *
1263 	 * Since: 2.30
1264 	 */
1265 	public string[] dupObjv()
1266 	{
1267 		size_t length;
1268 
1269 		auto retStr = g_variant_dup_objv(gVariant, &length);
1270 
1271 		scope(exit) Str.freeStringArray(retStr);
1272 		return Str.toStringArray(retStr, length);
1273 	}
1274 
1275 	/**
1276 	 * Similar to g_variant_get_string() except that instead of returning
1277 	 * a constant string, the string is duplicated.
1278 	 *
1279 	 * The string will always be UTF-8 encoded.
1280 	 *
1281 	 * The return value must be freed using g_free().
1282 	 *
1283 	 * Params:
1284 	 *     length = a pointer to a #gsize, to store the length
1285 	 *
1286 	 * Returns: a newly allocated string, UTF-8 encoded
1287 	 *
1288 	 * Since: 2.24
1289 	 */
1290 	public string dupString(out size_t length)
1291 	{
1292 		auto retStr = g_variant_dup_string(gVariant, &length);
1293 
1294 		scope(exit) Str.freeString(retStr);
1295 		return Str.toString(retStr);
1296 	}
1297 
1298 	/**
1299 	 * Gets the contents of an array of strings #GVariant.  This call
1300 	 * makes a deep copy; the return result should be released with
1301 	 * g_strfreev().
1302 	 *
1303 	 * If @length is non-%NULL then the number of elements in the result
1304 	 * is stored there.  In any case, the resulting array will be
1305 	 * %NULL-terminated.
1306 	 *
1307 	 * For an empty array, @length will be set to 0 and a pointer to a
1308 	 * %NULL pointer will be returned.
1309 	 *
1310 	 * Returns: an array of strings
1311 	 *
1312 	 * Since: 2.24
1313 	 */
1314 	public string[] dupStrv()
1315 	{
1316 		size_t length;
1317 
1318 		auto retStr = g_variant_dup_strv(gVariant, &length);
1319 
1320 		scope(exit) Str.freeStringArray(retStr);
1321 		return Str.toStringArray(retStr, length);
1322 	}
1323 
1324 	/**
1325 	 * Checks if @one and @two have the same type and value.
1326 	 *
1327 	 * The types of @one and @two are #gconstpointer only to allow use of
1328 	 * this function with #GHashTable.  They must each be a #GVariant.
1329 	 *
1330 	 * Params:
1331 	 *     two = a #GVariant instance
1332 	 *
1333 	 * Returns: %TRUE if @one and @two are equal
1334 	 *
1335 	 * Since: 2.24
1336 	 */
1337 	public bool equal(Variant two)
1338 	{
1339 		return g_variant_equal(gVariant, (two is null) ? null : two.getVariantStruct()) != 0;
1340 	}
1341 
1342 	/**
1343 	 * Returns the boolean value of @value.
1344 	 *
1345 	 * It is an error to call this function with a @value of any type
1346 	 * other than %G_VARIANT_TYPE_BOOLEAN.
1347 	 *
1348 	 * Returns: %TRUE or %FALSE
1349 	 *
1350 	 * Since: 2.24
1351 	 */
1352 	public bool getBoolean()
1353 	{
1354 		return g_variant_get_boolean(gVariant) != 0;
1355 	}
1356 
1357 	/**
1358 	 * Returns the byte value of @value.
1359 	 *
1360 	 * It is an error to call this function with a @value of any type
1361 	 * other than %G_VARIANT_TYPE_BYTE.
1362 	 *
1363 	 * Returns: a #guchar
1364 	 *
1365 	 * Since: 2.24
1366 	 */
1367 	public char getByte()
1368 	{
1369 		return g_variant_get_byte(gVariant);
1370 	}
1371 
1372 	/**
1373 	 * Returns the string value of a #GVariant instance with an
1374 	 * array-of-bytes type.  The string has no particular encoding.
1375 	 *
1376 	 * If the array does not end with a nul terminator character, the empty
1377 	 * string is returned.  For this reason, you can always trust that a
1378 	 * non-%NULL nul-terminated string will be returned by this function.
1379 	 *
1380 	 * If the array contains a nul terminator character somewhere other than
1381 	 * the last byte then the returned string is the string, up to the first
1382 	 * such nul character.
1383 	 *
1384 	 * g_variant_get_fixed_array() should be used instead if the array contains
1385 	 * arbitrary data that could not be nul-terminated or could contain nul bytes.
1386 	 *
1387 	 * It is an error to call this function with a @value that is not an
1388 	 * array of bytes.
1389 	 *
1390 	 * The return value remains valid as long as @value exists.
1391 	 *
1392 	 * Returns: the constant string
1393 	 *
1394 	 * Since: 2.26
1395 	 */
1396 	public string getBytestring()
1397 	{
1398 		return Str.toString(g_variant_get_bytestring(gVariant));
1399 	}
1400 
1401 	/**
1402 	 * Gets the contents of an array of array of bytes #GVariant.  This call
1403 	 * makes a shallow copy; the return result should be released with
1404 	 * g_free(), but the individual strings must not be modified.
1405 	 *
1406 	 * If @length is non-%NULL then the number of elements in the result is
1407 	 * stored there.  In any case, the resulting array will be
1408 	 * %NULL-terminated.
1409 	 *
1410 	 * For an empty array, @length will be set to 0 and a pointer to a
1411 	 * %NULL pointer will be returned.
1412 	 *
1413 	 * Returns: an array of constant strings
1414 	 *
1415 	 * Since: 2.26
1416 	 */
1417 	public string[] getBytestringArray()
1418 	{
1419 		size_t length;
1420 
1421 		return Str.toStringArray(g_variant_get_bytestring_array(gVariant, &length));
1422 	}
1423 
1424 	/**
1425 	 * Reads a child item out of a container #GVariant instance.  This
1426 	 * includes variants, maybes, arrays, tuples and dictionary
1427 	 * entries.  It is an error to call this function on any other type of
1428 	 * #GVariant.
1429 	 *
1430 	 * It is an error if @index_ is greater than the number of child items
1431 	 * in the container.  See g_variant_n_children().
1432 	 *
1433 	 * The returned value is never floating.  You should free it with
1434 	 * g_variant_unref() when you're done with it.
1435 	 *
1436 	 * This function is O(1).
1437 	 *
1438 	 * Params:
1439 	 *     index = the index of the child to fetch
1440 	 *
1441 	 * Returns: the child at the specified index
1442 	 *
1443 	 * Since: 2.24
1444 	 */
1445 	public Variant getChildValue(size_t index)
1446 	{
1447 		auto p = g_variant_get_child_value(gVariant, index);
1448 
1449 		if(p is null)
1450 		{
1451 			return null;
1452 		}
1453 
1454 		return new Variant(cast(GVariant*) p, true);
1455 	}
1456 
1457 	/**
1458 	 * Returns a pointer to the serialised form of a #GVariant instance.
1459 	 * The returned data may not be in fully-normalised form if read from an
1460 	 * untrusted source.  The returned data must not be freed; it remains
1461 	 * valid for as long as @value exists.
1462 	 *
1463 	 * If @value is a fixed-sized value that was deserialised from a
1464 	 * corrupted serialised container then %NULL may be returned.  In this
1465 	 * case, the proper thing to do is typically to use the appropriate
1466 	 * number of nul bytes in place of @value.  If @value is not fixed-sized
1467 	 * then %NULL is never returned.
1468 	 *
1469 	 * In the case that @value is already in serialised form, this function
1470 	 * is O(1).  If the value is not already in serialised form,
1471 	 * serialisation occurs implicitly and is approximately O(n) in the size
1472 	 * of the result.
1473 	 *
1474 	 * To deserialise the data returned by this function, in addition to the
1475 	 * serialised data, you must know the type of the #GVariant, and (if the
1476 	 * machine might be different) the endianness of the machine that stored
1477 	 * it. As a result, file formats or network messages that incorporate
1478 	 * serialised #GVariants must include this information either
1479 	 * implicitly (for instance "the file always contains a
1480 	 * %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or
1481 	 * explicitly (by storing the type and/or endianness in addition to the
1482 	 * serialised data).
1483 	 *
1484 	 * Returns: the serialised form of @value, or %NULL
1485 	 *
1486 	 * Since: 2.24
1487 	 */
1488 	public void* getData()
1489 	{
1490 		return g_variant_get_data(gVariant);
1491 	}
1492 
1493 	/**
1494 	 * Returns a pointer to the serialised form of a #GVariant instance.
1495 	 * The semantics of this function are exactly the same as
1496 	 * g_variant_get_data(), except that the returned #GBytes holds
1497 	 * a reference to the variant data.
1498 	 *
1499 	 * Returns: A new #GBytes representing the variant data
1500 	 *
1501 	 * Since: 2.36
1502 	 */
1503 	public Bytes getDataAsBytes()
1504 	{
1505 		auto p = g_variant_get_data_as_bytes(gVariant);
1506 
1507 		if(p is null)
1508 		{
1509 			return null;
1510 		}
1511 
1512 		return new Bytes(cast(GBytes*) p, true);
1513 	}
1514 
1515 	/**
1516 	 * Returns the double precision floating point value of @value.
1517 	 *
1518 	 * It is an error to call this function with a @value of any type
1519 	 * other than %G_VARIANT_TYPE_DOUBLE.
1520 	 *
1521 	 * Returns: a #gdouble
1522 	 *
1523 	 * Since: 2.24
1524 	 */
1525 	public double getDouble()
1526 	{
1527 		return g_variant_get_double(gVariant);
1528 	}
1529 
1530 	/**
1531 	 * Provides access to the serialised data for an array of fixed-sized
1532 	 * items.
1533 	 *
1534 	 * @value must be an array with fixed-sized elements.  Numeric types are
1535 	 * fixed-size, as are tuples containing only other fixed-sized types.
1536 	 *
1537 	 * @element_size must be the size of a single element in the array,
1538 	 * as given by the section on
1539 	 * [serialized data memory][gvariant-serialised-data-memory].
1540 	 *
1541 	 * In particular, arrays of these fixed-sized types can be interpreted
1542 	 * as an array of the given C type, with @element_size set to the size
1543 	 * the appropriate type:
1544 	 * - %G_VARIANT_TYPE_INT16 (etc.): #gint16 (etc.)
1545 	 * - %G_VARIANT_TYPE_BOOLEAN: #guchar (not #gboolean!)
1546 	 * - %G_VARIANT_TYPE_BYTE: #guchar
1547 	 * - %G_VARIANT_TYPE_HANDLE: #guint32
1548 	 * - %G_VARIANT_TYPE_DOUBLE: #gdouble
1549 	 *
1550 	 * For example, if calling this function for an array of 32-bit integers,
1551 	 * you might say `sizeof(gint32)`. This value isn't used except for the purpose
1552 	 * of a double-check that the form of the serialised data matches the caller's
1553 	 * expectation.
1554 	 *
1555 	 * @n_elements, which must be non-%NULL, is set equal to the number of
1556 	 * items in the array.
1557 	 *
1558 	 * Params:
1559 	 *     elementSize = the size of each element
1560 	 *
1561 	 * Returns: a pointer to
1562 	 *     the fixed array
1563 	 *
1564 	 * Since: 2.24
1565 	 */
1566 	public void[] getFixedArray(size_t elementSize)
1567 	{
1568 		size_t nElements;
1569 
1570 		auto p = g_variant_get_fixed_array(gVariant, &nElements, elementSize);
1571 
1572 		return p[0 .. nElements];
1573 	}
1574 
1575 	/**
1576 	 * Returns the 32-bit signed integer value of @value.
1577 	 *
1578 	 * It is an error to call this function with a @value of any type other
1579 	 * than %G_VARIANT_TYPE_HANDLE.
1580 	 *
1581 	 * By convention, handles are indexes into an array of file descriptors
1582 	 * that are sent alongside a D-Bus message.  If you're not interacting
1583 	 * with D-Bus, you probably don't need them.
1584 	 *
1585 	 * Returns: a #gint32
1586 	 *
1587 	 * Since: 2.24
1588 	 */
1589 	public int getHandle()
1590 	{
1591 		return g_variant_get_handle(gVariant);
1592 	}
1593 
1594 	/**
1595 	 * Returns the 16-bit signed integer value of @value.
1596 	 *
1597 	 * It is an error to call this function with a @value of any type
1598 	 * other than %G_VARIANT_TYPE_INT16.
1599 	 *
1600 	 * Returns: a #gint16
1601 	 *
1602 	 * Since: 2.24
1603 	 */
1604 	public short getInt16()
1605 	{
1606 		return g_variant_get_int16(gVariant);
1607 	}
1608 
1609 	/**
1610 	 * Returns the 32-bit signed integer value of @value.
1611 	 *
1612 	 * It is an error to call this function with a @value of any type
1613 	 * other than %G_VARIANT_TYPE_INT32.
1614 	 *
1615 	 * Returns: a #gint32
1616 	 *
1617 	 * Since: 2.24
1618 	 */
1619 	public int getInt32()
1620 	{
1621 		return g_variant_get_int32(gVariant);
1622 	}
1623 
1624 	/**
1625 	 * Returns the 64-bit signed integer value of @value.
1626 	 *
1627 	 * It is an error to call this function with a @value of any type
1628 	 * other than %G_VARIANT_TYPE_INT64.
1629 	 *
1630 	 * Returns: a #gint64
1631 	 *
1632 	 * Since: 2.24
1633 	 */
1634 	public long getInt64()
1635 	{
1636 		return g_variant_get_int64(gVariant);
1637 	}
1638 
1639 	/**
1640 	 * Given a maybe-typed #GVariant instance, extract its value.  If the
1641 	 * value is Nothing, then this function returns %NULL.
1642 	 *
1643 	 * Returns: the contents of @value, or %NULL
1644 	 *
1645 	 * Since: 2.24
1646 	 */
1647 	public Variant getMaybe()
1648 	{
1649 		auto p = g_variant_get_maybe(gVariant);
1650 
1651 		if(p is null)
1652 		{
1653 			return null;
1654 		}
1655 
1656 		return new Variant(cast(GVariant*) p, true);
1657 	}
1658 
1659 	/**
1660 	 * Gets a #GVariant instance that has the same value as @value and is
1661 	 * trusted to be in normal form.
1662 	 *
1663 	 * If @value is already trusted to be in normal form then a new
1664 	 * reference to @value is returned.
1665 	 *
1666 	 * If @value is not already trusted, then it is scanned to check if it
1667 	 * is in normal form.  If it is found to be in normal form then it is
1668 	 * marked as trusted and a new reference to it is returned.
1669 	 *
1670 	 * If @value is found not to be in normal form then a new trusted
1671 	 * #GVariant is created with the same value as @value.
1672 	 *
1673 	 * It makes sense to call this function if you've received #GVariant
1674 	 * data from untrusted sources and you want to ensure your serialised
1675 	 * output is definitely in normal form.
1676 	 *
1677 	 * If @value is already in normal form, a new reference will be returned
1678 	 * (which will be floating if @value is floating). If it is not in normal form,
1679 	 * the newly created #GVariant will be returned with a single non-floating
1680 	 * reference. Typically, g_variant_take_ref() should be called on the return
1681 	 * value from this function to guarantee ownership of a single non-floating
1682 	 * reference to it.
1683 	 *
1684 	 * Returns: a trusted #GVariant
1685 	 *
1686 	 * Since: 2.24
1687 	 */
1688 	public Variant getNormalForm()
1689 	{
1690 		auto p = g_variant_get_normal_form(gVariant);
1691 
1692 		if(p is null)
1693 		{
1694 			return null;
1695 		}
1696 
1697 		return new Variant(cast(GVariant*) p, true);
1698 	}
1699 
1700 	/**
1701 	 * Gets the contents of an array of object paths #GVariant.  This call
1702 	 * makes a shallow copy; the return result should be released with
1703 	 * g_free(), but the individual strings must not be modified.
1704 	 *
1705 	 * If @length is non-%NULL then the number of elements in the result
1706 	 * is stored there.  In any case, the resulting array will be
1707 	 * %NULL-terminated.
1708 	 *
1709 	 * For an empty array, @length will be set to 0 and a pointer to a
1710 	 * %NULL pointer will be returned.
1711 	 *
1712 	 * Returns: an array of constant strings
1713 	 *
1714 	 * Since: 2.30
1715 	 */
1716 	public string[] getObjv()
1717 	{
1718 		size_t length;
1719 
1720 		return Str.toStringArray(g_variant_get_objv(gVariant, &length));
1721 	}
1722 
1723 	/**
1724 	 * Determines the number of bytes that would be required to store @value
1725 	 * with g_variant_store().
1726 	 *
1727 	 * If @value has a fixed-sized type then this function always returned
1728 	 * that fixed size.
1729 	 *
1730 	 * In the case that @value is already in serialised form or the size has
1731 	 * already been calculated (ie: this function has been called before)
1732 	 * then this function is O(1).  Otherwise, the size is calculated, an
1733 	 * operation which is approximately O(n) in the number of values
1734 	 * involved.
1735 	 *
1736 	 * Returns: the serialised size of @value
1737 	 *
1738 	 * Since: 2.24
1739 	 */
1740 	public size_t getSize()
1741 	{
1742 		return g_variant_get_size(gVariant);
1743 	}
1744 
1745 	/**
1746 	 * Returns the string value of a #GVariant instance with a string
1747 	 * type.  This includes the types %G_VARIANT_TYPE_STRING,
1748 	 * %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE.
1749 	 *
1750 	 * The string will always be UTF-8 encoded, and will never be %NULL.
1751 	 *
1752 	 * If @length is non-%NULL then the length of the string (in bytes) is
1753 	 * returned there.  For trusted values, this information is already
1754 	 * known.  For untrusted values, a strlen() will be performed.
1755 	 *
1756 	 * It is an error to call this function with a @value of any type
1757 	 * other than those three.
1758 	 *
1759 	 * The return value remains valid as long as @value exists.
1760 	 *
1761 	 * Params:
1762 	 *     length = a pointer to a #gsize,
1763 	 *         to store the length
1764 	 *
1765 	 * Returns: the constant string, UTF-8 encoded
1766 	 *
1767 	 * Since: 2.24
1768 	 */
1769 	public string getString(out size_t length)
1770 	{
1771 		return Str.toString(g_variant_get_string(gVariant, &length));
1772 	}
1773 
1774 	/**
1775 	 * Gets the contents of an array of strings #GVariant.  This call
1776 	 * makes a shallow copy; the return result should be released with
1777 	 * g_free(), but the individual strings must not be modified.
1778 	 *
1779 	 * If @length is non-%NULL then the number of elements in the result
1780 	 * is stored there.  In any case, the resulting array will be
1781 	 * %NULL-terminated.
1782 	 *
1783 	 * For an empty array, @length will be set to 0 and a pointer to a
1784 	 * %NULL pointer will be returned.
1785 	 *
1786 	 * Returns: an array of constant strings
1787 	 *
1788 	 * Since: 2.24
1789 	 */
1790 	public string[] getStrv()
1791 	{
1792 		size_t length;
1793 
1794 		return Str.toStringArray(g_variant_get_strv(gVariant, &length));
1795 	}
1796 
1797 	/**
1798 	 * Determines the type of @value.
1799 	 *
1800 	 * The return value is valid for the lifetime of @value and must not
1801 	 * be freed.
1802 	 *
1803 	 * Returns: a #GVariantType
1804 	 *
1805 	 * Since: 2.24
1806 	 */
1807 	public VariantType getType()
1808 	{
1809 		auto p = g_variant_get_type(gVariant);
1810 
1811 		if(p is null)
1812 		{
1813 			return null;
1814 		}
1815 
1816 		return new VariantType(cast(GVariantType*) p);
1817 	}
1818 
1819 	/**
1820 	 * Returns the type string of @value.  Unlike the result of calling
1821 	 * g_variant_type_peek_string(), this string is nul-terminated.  This
1822 	 * string belongs to #GVariant and must not be freed.
1823 	 *
1824 	 * Returns: the type string for the type of @value
1825 	 *
1826 	 * Since: 2.24
1827 	 */
1828 	public string getTypeString()
1829 	{
1830 		return Str.toString(g_variant_get_type_string(gVariant));
1831 	}
1832 
1833 	/**
1834 	 * Returns the 16-bit unsigned integer value of @value.
1835 	 *
1836 	 * It is an error to call this function with a @value of any type
1837 	 * other than %G_VARIANT_TYPE_UINT16.
1838 	 *
1839 	 * Returns: a #guint16
1840 	 *
1841 	 * Since: 2.24
1842 	 */
1843 	public ushort getUint16()
1844 	{
1845 		return g_variant_get_uint16(gVariant);
1846 	}
1847 
1848 	/**
1849 	 * Returns the 32-bit unsigned integer value of @value.
1850 	 *
1851 	 * It is an error to call this function with a @value of any type
1852 	 * other than %G_VARIANT_TYPE_UINT32.
1853 	 *
1854 	 * Returns: a #guint32
1855 	 *
1856 	 * Since: 2.24
1857 	 */
1858 	public uint getUint32()
1859 	{
1860 		return g_variant_get_uint32(gVariant);
1861 	}
1862 
1863 	/**
1864 	 * Returns the 64-bit unsigned integer value of @value.
1865 	 *
1866 	 * It is an error to call this function with a @value of any type
1867 	 * other than %G_VARIANT_TYPE_UINT64.
1868 	 *
1869 	 * Returns: a #guint64
1870 	 *
1871 	 * Since: 2.24
1872 	 */
1873 	public ulong getUint64()
1874 	{
1875 		return g_variant_get_uint64(gVariant);
1876 	}
1877 
1878 	/**
1879 	 * This function is intended to be used by libraries based on #GVariant
1880 	 * that want to provide g_variant_get()-like functionality to their
1881 	 * users.
1882 	 *
1883 	 * The API is more general than g_variant_get() to allow a wider range
1884 	 * of possible uses.
1885 	 *
1886 	 * @format_string must still point to a valid format string, but it only
1887 	 * need to be nul-terminated if @endptr is %NULL.  If @endptr is
1888 	 * non-%NULL then it is updated to point to the first character past the
1889 	 * end of the format string.
1890 	 *
1891 	 * @app is a pointer to a #va_list.  The arguments, according to
1892 	 * @format_string, are collected from this #va_list and the list is left
1893 	 * pointing to the argument following the last.
1894 	 *
1895 	 * These two generalisations allow mixing of multiple calls to
1896 	 * g_variant_new_va() and g_variant_get_va() within a single actual
1897 	 * varargs call by the user.
1898 	 *
1899 	 * @format_string determines the C types that are used for unpacking
1900 	 * the values and also determines if the values are copied or borrowed,
1901 	 * see the section on
1902 	 * [GVariant format strings][gvariant-format-strings-pointers].
1903 	 *
1904 	 * Params:
1905 	 *     formatString = a string that is prefixed with a format string
1906 	 *     endptr = location to store the end pointer,
1907 	 *         or %NULL
1908 	 *     app = a pointer to a #va_list
1909 	 *
1910 	 * Since: 2.24
1911 	 */
1912 	public void getVa(string formatString, string[] endptr, void** app)
1913 	{
1914 		g_variant_get_va(gVariant, Str.toStringz(formatString), Str.toStringzArray(endptr), app);
1915 	}
1916 
1917 	/**
1918 	 * Unboxes @value.  The result is the #GVariant instance that was
1919 	 * contained in @value.
1920 	 *
1921 	 * Returns: the item contained in the variant
1922 	 *
1923 	 * Since: 2.24
1924 	 */
1925 	public Variant getVariant()
1926 	{
1927 		auto p = g_variant_get_variant(gVariant);
1928 
1929 		if(p is null)
1930 		{
1931 			return null;
1932 		}
1933 
1934 		return new Variant(cast(GVariant*) p, true);
1935 	}
1936 
1937 	/**
1938 	 * Generates a hash value for a #GVariant instance.
1939 	 *
1940 	 * The output of this function is guaranteed to be the same for a given
1941 	 * value only per-process.  It may change between different processor
1942 	 * architectures or even different versions of GLib.  Do not use this
1943 	 * function as a basis for building protocols or file formats.
1944 	 *
1945 	 * The type of @value is #gconstpointer only to allow use of this
1946 	 * function with #GHashTable.  @value must be a #GVariant.
1947 	 *
1948 	 * Returns: a hash value corresponding to @value
1949 	 *
1950 	 * Since: 2.24
1951 	 */
1952 	public uint hash()
1953 	{
1954 		return g_variant_hash(gVariant);
1955 	}
1956 
1957 	/**
1958 	 * Checks if @value is a container.
1959 	 *
1960 	 * Returns: %TRUE if @value is a container
1961 	 *
1962 	 * Since: 2.24
1963 	 */
1964 	public bool isContainer()
1965 	{
1966 		return g_variant_is_container(gVariant) != 0;
1967 	}
1968 
1969 	/**
1970 	 * Checks whether @value has a floating reference count.
1971 	 *
1972 	 * This function should only ever be used to assert that a given variant
1973 	 * is or is not floating, or for debug purposes. To acquire a reference
1974 	 * to a variant that might be floating, always use g_variant_ref_sink()
1975 	 * or g_variant_take_ref().
1976 	 *
1977 	 * See g_variant_ref_sink() for more information about floating reference
1978 	 * counts.
1979 	 *
1980 	 * Returns: whether @value is floating
1981 	 *
1982 	 * Since: 2.26
1983 	 */
1984 	public bool isFloating()
1985 	{
1986 		return g_variant_is_floating(gVariant) != 0;
1987 	}
1988 
1989 	/**
1990 	 * Checks if @value is in normal form.
1991 	 *
1992 	 * The main reason to do this is to detect if a given chunk of
1993 	 * serialised data is in normal form: load the data into a #GVariant
1994 	 * using g_variant_new_from_data() and then use this function to
1995 	 * check.
1996 	 *
1997 	 * If @value is found to be in normal form then it will be marked as
1998 	 * being trusted.  If the value was already marked as being trusted then
1999 	 * this function will immediately return %TRUE.
2000 	 *
2001 	 * Returns: %TRUE if @value is in normal form
2002 	 *
2003 	 * Since: 2.24
2004 	 */
2005 	public bool isNormalForm()
2006 	{
2007 		return g_variant_is_normal_form(gVariant) != 0;
2008 	}
2009 
2010 	/**
2011 	 * Checks if a value has a type matching the provided type.
2012 	 *
2013 	 * Params:
2014 	 *     type = a #GVariantType
2015 	 *
2016 	 * Returns: %TRUE if the type of @value matches @type
2017 	 *
2018 	 * Since: 2.24
2019 	 */
2020 	public bool isOfType(VariantType type)
2021 	{
2022 		return g_variant_is_of_type(gVariant, (type is null) ? null : type.getVariantTypeStruct()) != 0;
2023 	}
2024 
2025 	/**
2026 	 * Creates a heap-allocated #GVariantIter for iterating over the items
2027 	 * in @value.
2028 	 *
2029 	 * Use g_variant_iter_free() to free the return value when you no longer
2030 	 * need it.
2031 	 *
2032 	 * A reference is taken to @value and will be released only when
2033 	 * g_variant_iter_free() is called.
2034 	 *
2035 	 * Returns: a new heap-allocated #GVariantIter
2036 	 *
2037 	 * Since: 2.24
2038 	 */
2039 	public VariantIter iterNew()
2040 	{
2041 		auto p = g_variant_iter_new(gVariant);
2042 
2043 		if(p is null)
2044 		{
2045 			return null;
2046 		}
2047 
2048 		return new VariantIter(cast(GVariantIter*) p, true);
2049 	}
2050 
2051 	/**
2052 	 * Looks up a value in a dictionary #GVariant.
2053 	 *
2054 	 * This function works with dictionaries of the type a{s*} (and equally
2055 	 * well with type a{o*}, but we only further discuss the string case
2056 	 * for sake of clarity).
2057 	 *
2058 	 * In the event that @dictionary has the type a{sv}, the @expected_type
2059 	 * string specifies what type of value is expected to be inside of the
2060 	 * variant. If the value inside the variant has a different type then
2061 	 * %NULL is returned. In the event that @dictionary has a value type other
2062 	 * than v then @expected_type must directly match the key type and it is
2063 	 * used to unpack the value directly or an error occurs.
2064 	 *
2065 	 * In either case, if @key is not found in @dictionary, %NULL is returned.
2066 	 *
2067 	 * If the key is found and the value has the correct type, it is
2068 	 * returned.  If @expected_type was specified then any non-%NULL return
2069 	 * value will have this type.
2070 	 *
2071 	 * This function is currently implemented with a linear scan.  If you
2072 	 * plan to do many lookups then #GVariantDict may be more efficient.
2073 	 *
2074 	 * Params:
2075 	 *     key = the key to lookup in the dictionary
2076 	 *     expectedType = a #GVariantType, or %NULL
2077 	 *
2078 	 * Returns: the value of the dictionary key, or %NULL
2079 	 *
2080 	 * Since: 2.28
2081 	 */
2082 	public Variant lookupValue(string key, VariantType expectedType)
2083 	{
2084 		auto p = g_variant_lookup_value(gVariant, Str.toStringz(key), (expectedType is null) ? null : expectedType.getVariantTypeStruct());
2085 
2086 		if(p is null)
2087 		{
2088 			return null;
2089 		}
2090 
2091 		return new Variant(cast(GVariant*) p, true);
2092 	}
2093 
2094 	/**
2095 	 * Determines the number of children in a container #GVariant instance.
2096 	 * This includes variants, maybes, arrays, tuples and dictionary
2097 	 * entries.  It is an error to call this function on any other type of
2098 	 * #GVariant.
2099 	 *
2100 	 * For variants, the return value is always 1.  For values with maybe
2101 	 * types, it is always zero or one.  For arrays, it is the length of the
2102 	 * array.  For tuples it is the number of tuple items (which depends
2103 	 * only on the type).  For dictionary entries, it is always 2
2104 	 *
2105 	 * This function is O(1).
2106 	 *
2107 	 * Returns: the number of children in the container
2108 	 *
2109 	 * Since: 2.24
2110 	 */
2111 	public size_t nChildren()
2112 	{
2113 		return g_variant_n_children(gVariant);
2114 	}
2115 
2116 	/**
2117 	 * Pretty-prints @value in the format understood by g_variant_parse().
2118 	 *
2119 	 * The format is described [here][gvariant-text].
2120 	 *
2121 	 * If @type_annotate is %TRUE, then type information is included in
2122 	 * the output.
2123 	 *
2124 	 * Params:
2125 	 *     typeAnnotate = %TRUE if type information should be included in
2126 	 *         the output
2127 	 *
2128 	 * Returns: a newly-allocated string holding the result.
2129 	 *
2130 	 * Since: 2.24
2131 	 */
2132 	public string print(bool typeAnnotate)
2133 	{
2134 		auto retStr = g_variant_print(gVariant, typeAnnotate);
2135 
2136 		scope(exit) Str.freeString(retStr);
2137 		return Str.toString(retStr);
2138 	}
2139 
2140 	/**
2141 	 * Behaves as g_variant_print(), but operates on a #GString.
2142 	 *
2143 	 * If @string is non-%NULL then it is appended to and returned.  Else,
2144 	 * a new empty #GString is allocated and it is returned.
2145 	 *
2146 	 * Params:
2147 	 *     string_ = a #GString, or %NULL
2148 	 *     typeAnnotate = %TRUE if type information should be included in
2149 	 *         the output
2150 	 *
2151 	 * Returns: a #GString containing the string
2152 	 *
2153 	 * Since: 2.24
2154 	 */
2155 	public StringG printString(StringG string_, bool typeAnnotate)
2156 	{
2157 		auto p = g_variant_print_string(gVariant, (string_ is null) ? null : string_.getStringGStruct(), typeAnnotate);
2158 
2159 		if(p is null)
2160 		{
2161 			return null;
2162 		}
2163 
2164 		return new StringG(cast(GString*) p, true);
2165 	}
2166 
2167 	alias doref = ref_;
2168 	/**
2169 	 * Increases the reference count of @value.
2170 	 *
2171 	 * Returns: the same @value
2172 	 *
2173 	 * Since: 2.24
2174 	 */
2175 	public Variant ref_()
2176 	{
2177 		auto p = g_variant_ref(gVariant);
2178 
2179 		if(p is null)
2180 		{
2181 			return null;
2182 		}
2183 
2184 		return new Variant(cast(GVariant*) p, true);
2185 	}
2186 
2187 	/**
2188 	 * #GVariant uses a floating reference count system.  All functions with
2189 	 * names starting with `g_variant_new_` return floating
2190 	 * references.
2191 	 *
2192 	 * Calling g_variant_ref_sink() on a #GVariant with a floating reference
2193 	 * will convert the floating reference into a full reference.  Calling
2194 	 * g_variant_ref_sink() on a non-floating #GVariant results in an
2195 	 * additional normal reference being added.
2196 	 *
2197 	 * In other words, if the @value is floating, then this call "assumes
2198 	 * ownership" of the floating reference, converting it to a normal
2199 	 * reference.  If the @value is not floating, then this call adds a
2200 	 * new normal reference increasing the reference count by one.
2201 	 *
2202 	 * All calls that result in a #GVariant instance being inserted into a
2203 	 * container will call g_variant_ref_sink() on the instance.  This means
2204 	 * that if the value was just created (and has only its floating
2205 	 * reference) then the container will assume sole ownership of the value
2206 	 * at that point and the caller will not need to unreference it.  This
2207 	 * makes certain common styles of programming much easier while still
2208 	 * maintaining normal refcounting semantics in situations where values
2209 	 * are not floating.
2210 	 *
2211 	 * Returns: the same @value
2212 	 *
2213 	 * Since: 2.24
2214 	 */
2215 	public Variant refSink()
2216 	{
2217 		auto p = g_variant_ref_sink(gVariant);
2218 
2219 		if(p is null)
2220 		{
2221 			return null;
2222 		}
2223 
2224 		return new Variant(cast(GVariant*) p, true);
2225 	}
2226 
2227 	/**
2228 	 * Stores the serialised form of @value at @data.  @data should be
2229 	 * large enough.  See g_variant_get_size().
2230 	 *
2231 	 * The stored data is in machine native byte order but may not be in
2232 	 * fully-normalised form if read from an untrusted source.  See
2233 	 * g_variant_get_normal_form() for a solution.
2234 	 *
2235 	 * As with g_variant_get_data(), to be able to deserialise the
2236 	 * serialised variant successfully, its type and (if the destination
2237 	 * machine might be different) its endianness must also be available.
2238 	 *
2239 	 * This function is approximately O(n) in the size of @data.
2240 	 *
2241 	 * Params:
2242 	 *     data = the location to store the serialised data at
2243 	 *
2244 	 * Since: 2.24
2245 	 */
2246 	public void store(void* data)
2247 	{
2248 		g_variant_store(gVariant, data);
2249 	}
2250 
2251 	/**
2252 	 * If @value is floating, sink it.  Otherwise, do nothing.
2253 	 *
2254 	 * Typically you want to use g_variant_ref_sink() in order to
2255 	 * automatically do the correct thing with respect to floating or
2256 	 * non-floating references, but there is one specific scenario where
2257 	 * this function is helpful.
2258 	 *
2259 	 * The situation where this function is helpful is when creating an API
2260 	 * that allows the user to provide a callback function that returns a
2261 	 * #GVariant.  We certainly want to allow the user the flexibility to
2262 	 * return a non-floating reference from this callback (for the case
2263 	 * where the value that is being returned already exists).
2264 	 *
2265 	 * At the same time, the style of the #GVariant API makes it likely that
2266 	 * for newly-created #GVariant instances, the user can be saved some
2267 	 * typing if they are allowed to return a #GVariant with a floating
2268 	 * reference.
2269 	 *
2270 	 * Using this function on the return value of the user's callback allows
2271 	 * the user to do whichever is more convenient for them.  The caller
2272 	 * will alway receives exactly one full reference to the value: either
2273 	 * the one that was returned in the first place, or a floating reference
2274 	 * that has been converted to a full reference.
2275 	 *
2276 	 * This function has an odd interaction when combined with
2277 	 * g_variant_ref_sink() running at the same time in another thread on
2278 	 * the same #GVariant instance.  If g_variant_ref_sink() runs first then
2279 	 * the result will be that the floating reference is converted to a hard
2280 	 * reference.  If g_variant_take_ref() runs first then the result will
2281 	 * be that the floating reference is converted to a hard reference and
2282 	 * an additional reference on top of that one is added.  It is best to
2283 	 * avoid this situation.
2284 	 *
2285 	 * Returns: the same @value
2286 	 */
2287 	public Variant takeRef()
2288 	{
2289 		auto p = g_variant_take_ref(gVariant);
2290 
2291 		if(p is null)
2292 		{
2293 			return null;
2294 		}
2295 
2296 		return new Variant(cast(GVariant*) p, true);
2297 	}
2298 
2299 	/**
2300 	 * Decreases the reference count of @value.  When its reference count
2301 	 * drops to 0, the memory used by the variant is freed.
2302 	 *
2303 	 * Since: 2.24
2304 	 */
2305 	public void unref()
2306 	{
2307 		g_variant_unref(gVariant);
2308 	}
2309 
2310 	/**
2311 	 * Determines if a given string is a valid D-Bus object path.  You
2312 	 * should ensure that a string is a valid D-Bus object path before
2313 	 * passing it to g_variant_new_object_path().
2314 	 *
2315 	 * A valid object path starts with '/' followed by zero or more
2316 	 * sequences of characters separated by '/' characters.  Each sequence
2317 	 * must contain only the characters "[A-Z][a-z][0-9]_".  No sequence
2318 	 * (including the one following the final '/' character) may be empty.
2319 	 *
2320 	 * Params:
2321 	 *     string_ = a normal C nul-terminated string
2322 	 *
2323 	 * Returns: %TRUE if @string is a D-Bus object path
2324 	 *
2325 	 * Since: 2.24
2326 	 */
2327 	public static bool isObjectPath(string string_)
2328 	{
2329 		return g_variant_is_object_path(Str.toStringz(string_)) != 0;
2330 	}
2331 
2332 	/**
2333 	 * Determines if a given string is a valid D-Bus type signature.  You
2334 	 * should ensure that a string is a valid D-Bus type signature before
2335 	 * passing it to g_variant_new_signature().
2336 	 *
2337 	 * D-Bus type signatures consist of zero or more definite #GVariantType
2338 	 * strings in sequence.
2339 	 *
2340 	 * Params:
2341 	 *     string_ = a normal C nul-terminated string
2342 	 *
2343 	 * Returns: %TRUE if @string is a D-Bus type signature
2344 	 *
2345 	 * Since: 2.24
2346 	 */
2347 	public static bool isSignature(string string_)
2348 	{
2349 		return g_variant_is_signature(Str.toStringz(string_)) != 0;
2350 	}
2351 
2352 	/**
2353 	 * Parses a #GVariant from a text representation.
2354 	 *
2355 	 * A single #GVariant is parsed from the content of @text.
2356 	 *
2357 	 * The format is described [here][gvariant-text].
2358 	 *
2359 	 * The memory at @limit will never be accessed and the parser behaves as
2360 	 * if the character at @limit is the nul terminator.  This has the
2361 	 * effect of bounding @text.
2362 	 *
2363 	 * If @endptr is non-%NULL then @text is permitted to contain data
2364 	 * following the value that this function parses and @endptr will be
2365 	 * updated to point to the first character past the end of the text
2366 	 * parsed by this function.  If @endptr is %NULL and there is extra data
2367 	 * then an error is returned.
2368 	 *
2369 	 * If @type is non-%NULL then the value will be parsed to have that
2370 	 * type.  This may result in additional parse errors (in the case that
2371 	 * the parsed value doesn't fit the type) but may also result in fewer
2372 	 * errors (in the case that the type would have been ambiguous, such as
2373 	 * with empty arrays).
2374 	 *
2375 	 * In the event that the parsing is successful, the resulting #GVariant
2376 	 * is returned. It is never floating, and must be freed with
2377 	 * g_variant_unref().
2378 	 *
2379 	 * In case of any error, %NULL will be returned.  If @error is non-%NULL
2380 	 * then it will be set to reflect the error that occurred.
2381 	 *
2382 	 * Officially, the language understood by the parser is "any string
2383 	 * produced by g_variant_print()".
2384 	 *
2385 	 * Params:
2386 	 *     type = a #GVariantType, or %NULL
2387 	 *     text = a string containing a GVariant in text form
2388 	 *     limit = a pointer to the end of @text, or %NULL
2389 	 *     endptr = a location to store the end pointer, or %NULL
2390 	 *
2391 	 * Returns: a non-floating reference to a #GVariant, or %NULL
2392 	 *
2393 	 * Throws: GException on failure.
2394 	 */
2395 	public static Variant parse(VariantType type, string text, string limit, string[] endptr)
2396 	{
2397 		GError* err = null;
2398 
2399 		auto p = g_variant_parse((type is null) ? null : type.getVariantTypeStruct(), Str.toStringz(text), Str.toStringz(limit), Str.toStringzArray(endptr), &err);
2400 
2401 		if (err !is null)
2402 		{
2403 			throw new GException( new ErrorG(err) );
2404 		}
2405 
2406 		if(p is null)
2407 		{
2408 			return null;
2409 		}
2410 
2411 		return new Variant(cast(GVariant*) p, true);
2412 	}
2413 
2414 	/**
2415 	 * Pretty-prints a message showing the context of a #GVariant parse
2416 	 * error within the string for which parsing was attempted.
2417 	 *
2418 	 * The resulting string is suitable for output to the console or other
2419 	 * monospace media where newlines are treated in the usual way.
2420 	 *
2421 	 * The message will typically look something like one of the following:
2422 	 *
2423 	 * |[
2424 	 * unterminated string constant:
2425 	 * (1, 2, 3, 'abc
2426 	 * ^^^^
2427 	 * ]|
2428 	 *
2429 	 * or
2430 	 *
2431 	 * |[
2432 	 * unable to find a common type:
2433 	 * [1, 2, 3, 'str']
2434 	 * ^        ^^^^^
2435 	 * ]|
2436 	 *
2437 	 * The format of the message may change in a future version.
2438 	 *
2439 	 * @error must have come from a failed attempt to g_variant_parse() and
2440 	 * @source_str must be exactly the same string that caused the error.
2441 	 * If @source_str was not nul-terminated when you passed it to
2442 	 * g_variant_parse() then you must add nul termination before using this
2443 	 * function.
2444 	 *
2445 	 * Params:
2446 	 *     error = a #GError from the #GVariantParseError domain
2447 	 *     sourceStr = the string that was given to the parser
2448 	 *
2449 	 * Returns: the printed message
2450 	 *
2451 	 * Since: 2.40
2452 	 */
2453 	public static string parseErrorPrintContext(ErrorG error, string sourceStr)
2454 	{
2455 		auto retStr = g_variant_parse_error_print_context((error is null) ? null : error.getErrorGStruct(), Str.toStringz(sourceStr));
2456 
2457 		scope(exit) Str.freeString(retStr);
2458 		return Str.toString(retStr);
2459 	}
2460 
2461 	/** */
2462 	public static GQuark parseErrorQuark()
2463 	{
2464 		return g_variant_parse_error_quark();
2465 	}
2466 
2467 	/**
2468 	 * Same as g_variant_error_quark().
2469 	 *
2470 	 * Deprecated: Use g_variant_parse_error_quark() instead.
2471 	 */
2472 	public static GQuark parserGetErrorQuark()
2473 	{
2474 		return g_variant_parser_get_error_quark();
2475 	}
2476 }