1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
3 * Copyright © 2010 Christian Persch
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library 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 GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
28 #include <stdlib.h> /* qsort() */
30 #include "gvaluetypes.h"
31 #include "gtype-private.h"
32 #include "gvaluecollector.h"
39 /* --- value functions --- */
41 value_init_long0 (GValue *value)
43 value->data[0].v_long = 0;
47 value_copy_long0 (const GValue *src_value,
50 dest_value->data[0].v_long = src_value->data[0].v_long;
54 value_lcopy_char (const GValue *value,
55 guint n_collect_values,
56 GTypeCValue *collect_values,
59 gint8 *int8_p = collect_values[0].v_pointer;
62 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
64 *int8_p = value->data[0].v_int;
70 value_lcopy_boolean (const GValue *value,
71 guint n_collect_values,
72 GTypeCValue *collect_values,
75 gboolean *bool_p = collect_values[0].v_pointer;
78 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
80 *bool_p = value->data[0].v_int;
86 value_collect_int (GValue *value,
87 guint n_collect_values,
88 GTypeCValue *collect_values,
91 value->data[0].v_int = collect_values[0].v_int;
97 value_lcopy_int (const GValue *value,
98 guint n_collect_values,
99 GTypeCValue *collect_values,
102 gint *int_p = collect_values[0].v_pointer;
105 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
107 *int_p = value->data[0].v_int;
113 value_collect_long (GValue *value,
114 guint n_collect_values,
115 GTypeCValue *collect_values,
118 value->data[0].v_long = collect_values[0].v_long;
124 value_lcopy_long (const GValue *value,
125 guint n_collect_values,
126 GTypeCValue *collect_values,
129 glong *long_p = collect_values[0].v_pointer;
132 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
134 *long_p = value->data[0].v_long;
140 value_init_int64 (GValue *value)
142 value->data[0].v_int64 = 0;
146 value_copy_int64 (const GValue *src_value,
149 dest_value->data[0].v_int64 = src_value->data[0].v_int64;
153 value_collect_int64 (GValue *value,
154 guint n_collect_values,
155 GTypeCValue *collect_values,
158 value->data[0].v_int64 = collect_values[0].v_int64;
164 value_lcopy_int64 (const GValue *value,
165 guint n_collect_values,
166 GTypeCValue *collect_values,
169 gint64 *int64_p = collect_values[0].v_pointer;
172 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
174 *int64_p = value->data[0].v_int64;
180 value_init_float (GValue *value)
182 value->data[0].v_float = 0.0;
186 value_copy_float (const GValue *src_value,
189 dest_value->data[0].v_float = src_value->data[0].v_float;
193 value_collect_float (GValue *value,
194 guint n_collect_values,
195 GTypeCValue *collect_values,
198 value->data[0].v_float = collect_values[0].v_double;
204 value_lcopy_float (const GValue *value,
205 guint n_collect_values,
206 GTypeCValue *collect_values,
209 gfloat *float_p = collect_values[0].v_pointer;
212 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
214 *float_p = value->data[0].v_float;
220 value_init_double (GValue *value)
222 value->data[0].v_double = 0.0;
226 value_copy_double (const GValue *src_value,
229 dest_value->data[0].v_double = src_value->data[0].v_double;
233 value_collect_double (GValue *value,
234 guint n_collect_values,
235 GTypeCValue *collect_values,
238 value->data[0].v_double = collect_values[0].v_double;
244 value_lcopy_double (const GValue *value,
245 guint n_collect_values,
246 GTypeCValue *collect_values,
249 gdouble *double_p = collect_values[0].v_pointer;
252 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
254 *double_p = value->data[0].v_double;
260 value_init_string (GValue *value)
262 value->data[0].v_pointer = NULL;
266 value_free_string (GValue *value)
268 if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
269 g_free (value->data[0].v_pointer);
273 value_copy_string (const GValue *src_value,
276 dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
280 value_collect_string (GValue *value,
281 guint n_collect_values,
282 GTypeCValue *collect_values,
285 if (!collect_values[0].v_pointer)
286 value->data[0].v_pointer = NULL;
287 else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
289 value->data[0].v_pointer = collect_values[0].v_pointer;
290 value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
293 value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
299 value_lcopy_string (const GValue *value,
300 guint n_collect_values,
301 GTypeCValue *collect_values,
304 gchar **string_p = collect_values[0].v_pointer;
307 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
309 if (!value->data[0].v_pointer)
311 else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
312 *string_p = value->data[0].v_pointer;
314 *string_p = g_strdup (value->data[0].v_pointer);
320 value_init_pointer (GValue *value)
322 value->data[0].v_pointer = NULL;
326 value_copy_pointer (const GValue *src_value,
329 dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
333 value_peek_pointer0 (const GValue *value)
335 return value->data[0].v_pointer;
339 value_collect_pointer (GValue *value,
340 guint n_collect_values,
341 GTypeCValue *collect_values,
344 value->data[0].v_pointer = collect_values[0].v_pointer;
350 value_lcopy_pointer (const GValue *value,
351 guint n_collect_values,
352 GTypeCValue *collect_values,
355 gpointer *pointer_p = collect_values[0].v_pointer;
358 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
360 *pointer_p = value->data[0].v_pointer;
366 value_free_variant (GValue *value)
368 if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) &&
369 value->data[0].v_pointer)
370 g_variant_unref (value->data[0].v_pointer);
374 value_copy_variant (const GValue *src_value,
377 if (src_value->data[0].v_pointer)
378 dest_value->data[0].v_pointer = g_variant_ref_sink (src_value->data[0].v_pointer);
380 dest_value->data[0].v_pointer = NULL;
384 value_collect_variant (GValue *value,
385 guint n_collect_values,
386 GTypeCValue *collect_values,
389 if (!collect_values[0].v_pointer)
390 value->data[0].v_pointer = NULL;
391 else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
393 value->data[0].v_pointer = collect_values[0].v_pointer;
394 value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
397 value->data[0].v_pointer = g_variant_ref_sink (collect_values[0].v_pointer);
403 value_lcopy_variant (const GValue *value,
404 guint n_collect_values,
405 GTypeCValue *collect_values,
408 GVariant **variant_p = collect_values[0].v_pointer;
411 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
413 if (!value->data[0].v_pointer)
415 else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
416 *variant_p = value->data[0].v_pointer;
418 *variant_p = g_variant_ref_sink (value->data[0].v_pointer);
423 /* --- type initialization --- */
425 _g_value_types_init (void)
429 NULL, /* base_init */
430 NULL, /* base_destroy */
431 NULL, /* class_init */
432 NULL, /* class_destroy */
433 NULL, /* class_data */
434 0, /* instance_size */
436 NULL, /* instance_init */
437 NULL, /* value_table */
439 const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
442 /* G_TYPE_CHAR / G_TYPE_UCHAR
445 static const GTypeValueTable value_table = {
446 value_init_long0, /* value_init */
447 NULL, /* value_free */
448 value_copy_long0, /* value_copy */
449 NULL, /* value_peek_pointer */
450 "i", /* collect_format */
451 value_collect_int, /* collect_value */
452 "p", /* lcopy_format */
453 value_lcopy_char, /* lcopy_value */
455 info.value_table = &value_table;
456 type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
457 g_assert (type == G_TYPE_CHAR);
458 type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
459 g_assert (type == G_TYPE_UCHAR);
465 static const GTypeValueTable value_table = {
466 value_init_long0, /* value_init */
467 NULL, /* value_free */
468 value_copy_long0, /* value_copy */
469 NULL, /* value_peek_pointer */
470 "i", /* collect_format */
471 value_collect_int, /* collect_value */
472 "p", /* lcopy_format */
473 value_lcopy_boolean, /* lcopy_value */
475 info.value_table = &value_table;
476 type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
477 g_assert (type == G_TYPE_BOOLEAN);
480 /* G_TYPE_INT / G_TYPE_UINT
483 static const GTypeValueTable value_table = {
484 value_init_long0, /* value_init */
485 NULL, /* value_free */
486 value_copy_long0, /* value_copy */
487 NULL, /* value_peek_pointer */
488 "i", /* collect_format */
489 value_collect_int, /* collect_value */
490 "p", /* lcopy_format */
491 value_lcopy_int, /* lcopy_value */
493 info.value_table = &value_table;
494 type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
495 g_assert (type == G_TYPE_INT);
496 type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
497 g_assert (type == G_TYPE_UINT);
500 /* G_TYPE_LONG / G_TYPE_ULONG
503 static const GTypeValueTable value_table = {
504 value_init_long0, /* value_init */
505 NULL, /* value_free */
506 value_copy_long0, /* value_copy */
507 NULL, /* value_peek_pointer */
508 "l", /* collect_format */
509 value_collect_long, /* collect_value */
510 "p", /* lcopy_format */
511 value_lcopy_long, /* lcopy_value */
513 info.value_table = &value_table;
514 type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
515 g_assert (type == G_TYPE_LONG);
516 type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
517 g_assert (type == G_TYPE_ULONG);
520 /* G_TYPE_INT64 / G_TYPE_UINT64
523 static const GTypeValueTable value_table = {
524 value_init_int64, /* value_init */
525 NULL, /* value_free */
526 value_copy_int64, /* value_copy */
527 NULL, /* value_peek_pointer */
528 "q", /* collect_format */
529 value_collect_int64, /* collect_value */
530 "p", /* lcopy_format */
531 value_lcopy_int64, /* lcopy_value */
533 info.value_table = &value_table;
534 type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
535 g_assert (type == G_TYPE_INT64);
536 type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
537 g_assert (type == G_TYPE_UINT64);
543 static const GTypeValueTable value_table = {
544 value_init_float, /* value_init */
545 NULL, /* value_free */
546 value_copy_float, /* value_copy */
547 NULL, /* value_peek_pointer */
548 "d", /* collect_format */
549 value_collect_float, /* collect_value */
550 "p", /* lcopy_format */
551 value_lcopy_float, /* lcopy_value */
553 info.value_table = &value_table;
554 type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
555 g_assert (type == G_TYPE_FLOAT);
561 static const GTypeValueTable value_table = {
562 value_init_double, /* value_init */
563 NULL, /* value_free */
564 value_copy_double, /* value_copy */
565 NULL, /* value_peek_pointer */
566 "d", /* collect_format */
567 value_collect_double, /* collect_value */
568 "p", /* lcopy_format */
569 value_lcopy_double, /* lcopy_value */
571 info.value_table = &value_table;
572 type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
573 g_assert (type == G_TYPE_DOUBLE);
579 static const GTypeValueTable value_table = {
580 value_init_string, /* value_init */
581 value_free_string, /* value_free */
582 value_copy_string, /* value_copy */
583 value_peek_pointer0, /* value_peek_pointer */
584 "p", /* collect_format */
585 value_collect_string, /* collect_value */
586 "p", /* lcopy_format */
587 value_lcopy_string, /* lcopy_value */
589 info.value_table = &value_table;
590 type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
591 g_assert (type == G_TYPE_STRING);
597 static const GTypeValueTable value_table = {
598 value_init_pointer, /* value_init */
599 NULL, /* value_free */
600 value_copy_pointer, /* value_copy */
601 value_peek_pointer0, /* value_peek_pointer */
602 "p", /* collect_format */
603 value_collect_pointer, /* collect_value */
604 "p", /* lcopy_format */
605 value_lcopy_pointer, /* lcopy_value */
607 info.value_table = &value_table;
608 type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
609 g_assert (type == G_TYPE_POINTER);
615 static const GTypeValueTable value_table = {
616 value_init_pointer, /* value_init */
617 value_free_variant, /* value_free */
618 value_copy_variant, /* value_copy */
619 value_peek_pointer0, /* value_peek_pointer */
620 "p", /* collect_format */
621 value_collect_variant, /* collect_value */
622 "p", /* lcopy_format */
623 value_lcopy_variant, /* lcopy_value */
625 info.value_table = &value_table;
626 type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0);
627 g_assert (type == G_TYPE_VARIANT);
632 /* --- GValue functions --- */
635 * @value: a valid #GValue of type %G_TYPE_CHAR
636 * @v_char: character value to be set
638 * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
639 * Deprecated: 2.32: This function's input type is broken, see g_value_set_schar()
642 g_value_set_char (GValue *value,
645 g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
647 value->data[0].v_int = v_char;
652 * @value: a valid #GValue of type %G_TYPE_CHAR
654 * Do not use this function; it is broken on platforms where the %char
655 * type is unsigned, such as ARM and PowerPC. See g_value_get_schar().
657 * Get the contents of a %G_TYPE_CHAR #GValue.
659 * Returns: character contents of @value
660 * Deprecated: 2.32: This function's return type is broken, see g_value_get_schar()
663 g_value_get_char (const GValue *value)
665 g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
667 return value->data[0].v_int;
672 * @value: a valid #GValue of type %G_TYPE_CHAR
673 * @v_char: signed 8 bit integer to be set
675 * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
680 g_value_set_schar (GValue *value,
683 g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
685 value->data[0].v_int = v_char;
690 * @value: a valid #GValue of type %G_TYPE_CHAR
692 * Get the contents of a %G_TYPE_CHAR #GValue.
694 * Returns: signed 8 bit integer contents of @value
698 g_value_get_schar (const GValue *value)
700 g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
702 return value->data[0].v_int;
707 * @value: a valid #GValue of type %G_TYPE_UCHAR
708 * @v_uchar: unsigned character value to be set
710 * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
713 g_value_set_uchar (GValue *value,
716 g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
718 value->data[0].v_uint = v_uchar;
723 * @value: a valid #GValue of type %G_TYPE_UCHAR
725 * Get the contents of a %G_TYPE_UCHAR #GValue.
727 * Returns: unsigned character contents of @value
730 g_value_get_uchar (const GValue *value)
732 g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
734 return value->data[0].v_uint;
738 * g_value_set_boolean:
739 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
740 * @v_boolean: boolean value to be set
742 * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
745 g_value_set_boolean (GValue *value,
748 g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
750 value->data[0].v_int = v_boolean != FALSE;
754 * g_value_get_boolean:
755 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
757 * Get the contents of a %G_TYPE_BOOLEAN #GValue.
759 * Returns: boolean contents of @value
762 g_value_get_boolean (const GValue *value)
764 g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
766 return value->data[0].v_int;
771 * @value: a valid #GValue of type %G_TYPE_INT
772 * @v_int: integer value to be set
774 * Set the contents of a %G_TYPE_INT #GValue to @v_int.
777 g_value_set_int (GValue *value,
780 g_return_if_fail (G_VALUE_HOLDS_INT (value));
782 value->data[0].v_int = v_int;
787 * @value: a valid #GValue of type %G_TYPE_INT
789 * Get the contents of a %G_TYPE_INT #GValue.
791 * Returns: integer contents of @value
794 g_value_get_int (const GValue *value)
796 g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
798 return value->data[0].v_int;
803 * @value: a valid #GValue of type %G_TYPE_UINT
804 * @v_uint: unsigned integer value to be set
806 * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
809 g_value_set_uint (GValue *value,
812 g_return_if_fail (G_VALUE_HOLDS_UINT (value));
814 value->data[0].v_uint = v_uint;
819 * @value: a valid #GValue of type %G_TYPE_UINT
821 * Get the contents of a %G_TYPE_UINT #GValue.
823 * Returns: unsigned integer contents of @value
826 g_value_get_uint (const GValue *value)
828 g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
830 return value->data[0].v_uint;
835 * @value: a valid #GValue of type %G_TYPE_LONG
836 * @v_long: long integer value to be set
838 * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
841 g_value_set_long (GValue *value,
844 g_return_if_fail (G_VALUE_HOLDS_LONG (value));
846 value->data[0].v_long = v_long;
851 * @value: a valid #GValue of type %G_TYPE_LONG
853 * Get the contents of a %G_TYPE_LONG #GValue.
855 * Returns: long integer contents of @value
858 g_value_get_long (const GValue *value)
860 g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
862 return value->data[0].v_long;
867 * @value: a valid #GValue of type %G_TYPE_ULONG
868 * @v_ulong: unsigned long integer value to be set
870 * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
873 g_value_set_ulong (GValue *value,
876 g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
878 value->data[0].v_ulong = v_ulong;
883 * @value: a valid #GValue of type %G_TYPE_ULONG
885 * Get the contents of a %G_TYPE_ULONG #GValue.
887 * Returns: unsigned long integer contents of @value
890 g_value_get_ulong (const GValue *value)
892 g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
894 return value->data[0].v_ulong;
899 * @value: a valid #GValue of type %G_TYPE_INT64
901 * Get the contents of a %G_TYPE_INT64 #GValue.
903 * Returns: 64bit integer contents of @value
906 g_value_set_int64 (GValue *value,
909 g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
911 value->data[0].v_int64 = v_int64;
916 * @value: a valid #GValue of type %G_TYPE_INT64
917 * @v_int64: 64bit integer value to be set
919 * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
922 g_value_get_int64 (const GValue *value)
924 g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
926 return value->data[0].v_int64;
930 * g_value_set_uint64:
931 * @value: a valid #GValue of type %G_TYPE_UINT64
932 * @v_uint64: unsigned 64bit integer value to be set
934 * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
937 g_value_set_uint64 (GValue *value,
940 g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
942 value->data[0].v_uint64 = v_uint64;
946 * g_value_get_uint64:
947 * @value: a valid #GValue of type %G_TYPE_UINT64
949 * Get the contents of a %G_TYPE_UINT64 #GValue.
951 * Returns: unsigned 64bit integer contents of @value
954 g_value_get_uint64 (const GValue *value)
956 g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
958 return value->data[0].v_uint64;
963 * @value: a valid #GValue of type %G_TYPE_FLOAT
964 * @v_float: float value to be set
966 * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
969 g_value_set_float (GValue *value,
972 g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
974 value->data[0].v_float = v_float;
979 * @value: a valid #GValue of type %G_TYPE_FLOAT
981 * Get the contents of a %G_TYPE_FLOAT #GValue.
983 * Returns: float contents of @value
986 g_value_get_float (const GValue *value)
988 g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
990 return value->data[0].v_float;
994 * g_value_set_double:
995 * @value: a valid #GValue of type %G_TYPE_DOUBLE
996 * @v_double: double value to be set
998 * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
1001 g_value_set_double (GValue *value,
1004 g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
1006 value->data[0].v_double = v_double;
1010 * g_value_get_double:
1011 * @value: a valid #GValue of type %G_TYPE_DOUBLE
1013 * Get the contents of a %G_TYPE_DOUBLE #GValue.
1015 * Returns: double contents of @value
1018 g_value_get_double (const GValue *value)
1020 g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
1022 return value->data[0].v_double;
1026 * g_value_set_string:
1027 * @value: a valid #GValue of type %G_TYPE_STRING
1028 * @v_string: (allow-none): caller-owned string to be duplicated for the #GValue
1030 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1033 g_value_set_string (GValue *value,
1034 const gchar *v_string)
1038 g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1040 new_val = g_strdup (v_string);
1042 if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1043 value->data[1].v_uint = 0;
1045 g_free (value->data[0].v_pointer);
1047 value->data[0].v_pointer = new_val;
1051 * g_value_set_static_string:
1052 * @value: a valid #GValue of type %G_TYPE_STRING
1053 * @v_string: (allow-none): static string to be set
1055 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1056 * The string is assumed to be static, and is thus not duplicated
1057 * when setting the #GValue.
1060 g_value_set_static_string (GValue *value,
1061 const gchar *v_string)
1063 g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1065 if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
1066 g_free (value->data[0].v_pointer);
1067 value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
1068 value->data[0].v_pointer = (gchar*) v_string;
1072 * g_value_set_string_take_ownership:
1073 * @value: a valid #GValue of type %G_TYPE_STRING
1074 * @v_string: (allow-none): duplicated unowned string to be set
1076 * This is an internal function introduced mainly for C marshallers.
1078 * Deprecated: 2.4: Use g_value_take_string() instead.
1081 g_value_set_string_take_ownership (GValue *value,
1084 g_value_take_string (value, v_string);
1088 * g_value_take_string:
1089 * @value: a valid #GValue of type %G_TYPE_STRING
1090 * @v_string: (allow-none): string to take ownership of
1092 * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1097 g_value_take_string (GValue *value,
1100 g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1102 if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1103 value->data[1].v_uint = 0;
1105 g_free (value->data[0].v_pointer);
1106 value->data[0].v_pointer = v_string;
1110 * g_value_get_string:
1111 * @value: a valid #GValue of type %G_TYPE_STRING
1113 * Get the contents of a %G_TYPE_STRING #GValue.
1115 * Returns: string content of @value
1118 g_value_get_string (const GValue *value)
1120 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1122 return value->data[0].v_pointer;
1126 * g_value_dup_string:
1127 * @value: a valid #GValue of type %G_TYPE_STRING
1129 * Get a copy the contents of a %G_TYPE_STRING #GValue.
1131 * Returns: a newly allocated copy of the string content of @value
1134 g_value_dup_string (const GValue *value)
1136 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1138 return g_strdup (value->data[0].v_pointer);
1142 * g_value_set_pointer:
1143 * @value: a valid #GValue of %G_TYPE_POINTER
1144 * @v_pointer: pointer value to be set
1146 * Set the contents of a pointer #GValue to @v_pointer.
1149 g_value_set_pointer (GValue *value,
1152 g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1154 value->data[0].v_pointer = v_pointer;
1158 * g_value_get_pointer:
1159 * @value: a valid #GValue of %G_TYPE_POINTER
1161 * Get the contents of a pointer #GValue.
1163 * Returns: (transfer none): pointer contents of @value
1166 g_value_get_pointer (const GValue *value)
1168 g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1170 return value->data[0].v_pointer;
1173 G_DEFINE_POINTER_TYPE (GType, g_gtype)
1176 * g_value_set_gtype:
1177 * @value: a valid #GValue of type %G_TYPE_GTYPE
1178 * @v_gtype: #GType to be set
1180 * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1185 g_value_set_gtype (GValue *value,
1188 g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1190 value->data[0].v_long = v_gtype;
1195 * g_value_get_gtype:
1196 * @value: a valid #GValue of type %G_TYPE_GTYPE
1198 * Get the contents of a %G_TYPE_GTYPE #GValue.
1202 * Returns: the #GType stored in @value
1205 g_value_get_gtype (const GValue *value)
1207 g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1209 return value->data[0].v_long;
1213 * g_value_set_variant:
1214 * @value: a valid #GValue of type %G_TYPE_VARIANT
1215 * @variant: (allow-none): a #GVariant, or %NULL
1217 * Set the contents of a variant #GValue to @variant.
1218 * If the variant is floating, it is consumed.
1223 g_value_set_variant (GValue *value,
1226 GVariant *old_variant;
1228 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1230 old_variant = value->data[0].v_pointer;
1233 value->data[0].v_pointer = g_variant_ref_sink (variant);
1235 value->data[0].v_pointer = NULL;
1238 g_variant_unref (old_variant);
1242 * g_value_take_variant:
1243 * @value: a valid #GValue of type %G_TYPE_VARIANT
1244 * @variant: (allow-none): a #GVariant, or %NULL
1246 * Set the contents of a variant #GValue to @variant, and takes over
1247 * the ownership of the caller's reference to @variant;
1248 * the caller doesn't have to unref it any more (i.e. the reference
1249 * count of the variant is not increased).
1251 * If @variant was floating then its floating reference is converted to
1254 * If you want the #GValue to hold its own reference to @variant, use
1255 * g_value_set_variant() instead.
1257 * This is an internal function introduced mainly for C marshallers.
1262 g_value_take_variant (GValue *value,
1265 GVariant *old_variant;
1267 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1269 old_variant = value->data[0].v_pointer;
1272 value->data[0].v_pointer = g_variant_take_ref (variant);
1274 value->data[0].v_pointer = NULL;
1277 g_variant_unref (old_variant);
1281 * g_value_get_variant:
1282 * @value: a valid #GValue of type %G_TYPE_VARIANT
1284 * Get the contents of a variant #GValue.
1286 * Returns: variant contents of @value
1291 g_value_get_variant (const GValue *value)
1293 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1295 return value->data[0].v_pointer;
1299 * g_value_dup_variant:
1300 * @value: a valid #GValue of type %G_TYPE_VARIANT
1302 * Get the contents of a variant #GValue, increasing its refcount.
1304 * Returns: variant contents of @value, should be unrefed using
1305 * g_variant_unref() when no longer needed
1310 g_value_dup_variant (const GValue *value)
1314 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1316 variant = value->data[0].v_pointer;
1318 g_variant_ref_sink (variant);
1324 * g_strdup_value_contents:
1325 * @value: #GValue which contents are to be described.
1327 * Return a newly allocated string, which describes the contents of a
1328 * #GValue. The main purpose of this function is to describe #GValue
1329 * contents for debugging output, the way in which the contents are
1330 * described may change between different GLib versions.
1332 * Returns: Newly allocated string.
1335 g_strdup_value_contents (const GValue *value)
1340 g_return_val_if_fail (G_IS_VALUE (value), NULL);
1342 if (G_VALUE_HOLDS_STRING (value))
1344 src = g_value_get_string (value);
1347 contents = g_strdup ("NULL");
1350 gchar *s = g_strescape (src, NULL);
1352 contents = g_strdup_printf ("\"%s\"", s);
1356 else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1358 GValue tmp_value = { 0, };
1361 g_value_init (&tmp_value, G_TYPE_STRING);
1362 g_value_transform (value, &tmp_value);
1363 s = g_strescape (g_value_get_string (&tmp_value), NULL);
1364 g_value_unset (&tmp_value);
1365 if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
1366 contents = g_strdup_printf ("((%s) %s)",
1367 g_type_name (G_VALUE_TYPE (value)),
1370 contents = g_strdup (s ? s : "NULL");
1373 else if (g_value_fits_pointer (value))
1375 gpointer p = g_value_peek_pointer (value);
1378 contents = g_strdup ("NULL");
1379 else if (G_VALUE_HOLDS_OBJECT (value))
1380 contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
1381 else if (G_VALUE_HOLDS_PARAM (value))
1382 contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
1383 else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
1385 GStrv strv = g_value_get_boxed (value);
1386 GString *tmp = g_string_new ("[");
1388 while (*strv != NULL)
1390 gchar *escaped = g_strescape (*strv, NULL);
1392 g_string_append_printf (tmp, "\"%s\"", escaped);
1395 if (*++strv != NULL)
1396 g_string_append (tmp, ", ");
1399 g_string_append (tmp, "]");
1400 contents = g_string_free (tmp, FALSE);
1402 else if (G_VALUE_HOLDS_BOXED (value))
1403 contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
1404 else if (G_VALUE_HOLDS_POINTER (value))
1405 contents = g_strdup_printf ("((gpointer) %p)", p);
1407 contents = g_strdup ("???");
1410 contents = g_strdup ("???");
1416 * g_pointer_type_register_static:
1417 * @name: the name of the new pointer type.
1419 * Creates a new %G_TYPE_POINTER derived type id for a new
1420 * pointer type with name @name.
1422 * Returns: a new %G_TYPE_POINTER derived type id for @name.
1425 g_pointer_type_register_static (const gchar *name)
1427 static const GTypeInfo type_info = {
1429 NULL, /* base_init */
1430 NULL, /* base_finalize */
1431 NULL, /* class_init */
1432 NULL, /* class_finalize */
1433 NULL, /* class_data */
1434 0, /* instance_size */
1435 0, /* n_preallocs */
1436 NULL, /* instance_init */
1437 NULL /* value_table */
1441 g_return_val_if_fail (name != NULL, 0);
1442 g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1444 type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);