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.
641 g_value_set_char (GValue
*value
,
644 g_return_if_fail (G_VALUE_HOLDS_CHAR (value
));
646 value
->data
[0].v_int
= v_char
;
651 * @value: a valid #GValue of type %G_TYPE_CHAR
653 * Get the contents of a %G_TYPE_CHAR #GValue.
655 * Returns: character contents of @value
658 g_value_get_char (const GValue
*value
)
660 g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value
), 0);
662 return value
->data
[0].v_int
;
667 * @value: a valid #GValue of type %G_TYPE_UCHAR
668 * @v_uchar: unsigned character value to be set
670 * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
673 g_value_set_uchar (GValue
*value
,
676 g_return_if_fail (G_VALUE_HOLDS_UCHAR (value
));
678 value
->data
[0].v_uint
= v_uchar
;
683 * @value: a valid #GValue of type %G_TYPE_UCHAR
685 * Get the contents of a %G_TYPE_UCHAR #GValue.
687 * Returns: unsigned character contents of @value
690 g_value_get_uchar (const GValue
*value
)
692 g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value
), 0);
694 return value
->data
[0].v_uint
;
698 * g_value_set_boolean:
699 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
700 * @v_boolean: boolean value to be set
702 * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
705 g_value_set_boolean (GValue
*value
,
708 g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value
));
710 value
->data
[0].v_int
= v_boolean
!= FALSE
;
714 * g_value_get_boolean:
715 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
717 * Get the contents of a %G_TYPE_BOOLEAN #GValue.
719 * Returns: boolean contents of @value
722 g_value_get_boolean (const GValue
*value
)
724 g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value
), 0);
726 return value
->data
[0].v_int
;
731 * @value: a valid #GValue of type %G_TYPE_INT
732 * @v_int: integer value to be set
734 * Set the contents of a %G_TYPE_INT #GValue to @v_int.
737 g_value_set_int (GValue
*value
,
740 g_return_if_fail (G_VALUE_HOLDS_INT (value
));
742 value
->data
[0].v_int
= v_int
;
747 * @value: a valid #GValue of type %G_TYPE_INT
749 * Get the contents of a %G_TYPE_INT #GValue.
751 * Returns: integer contents of @value
754 g_value_get_int (const GValue
*value
)
756 g_return_val_if_fail (G_VALUE_HOLDS_INT (value
), 0);
758 return value
->data
[0].v_int
;
763 * @value: a valid #GValue of type %G_TYPE_UINT
764 * @v_uint: unsigned integer value to be set
766 * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
769 g_value_set_uint (GValue
*value
,
772 g_return_if_fail (G_VALUE_HOLDS_UINT (value
));
774 value
->data
[0].v_uint
= v_uint
;
779 * @value: a valid #GValue of type %G_TYPE_UINT
781 * Get the contents of a %G_TYPE_UINT #GValue.
783 * Returns: unsigned integer contents of @value
786 g_value_get_uint (const GValue
*value
)
788 g_return_val_if_fail (G_VALUE_HOLDS_UINT (value
), 0);
790 return value
->data
[0].v_uint
;
795 * @value: a valid #GValue of type %G_TYPE_LONG
796 * @v_long: long integer value to be set
798 * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
801 g_value_set_long (GValue
*value
,
804 g_return_if_fail (G_VALUE_HOLDS_LONG (value
));
806 value
->data
[0].v_long
= v_long
;
811 * @value: a valid #GValue of type %G_TYPE_LONG
813 * Get the contents of a %G_TYPE_LONG #GValue.
815 * Returns: long integer contents of @value
818 g_value_get_long (const GValue
*value
)
820 g_return_val_if_fail (G_VALUE_HOLDS_LONG (value
), 0);
822 return value
->data
[0].v_long
;
827 * @value: a valid #GValue of type %G_TYPE_ULONG
828 * @v_ulong: unsigned long integer value to be set
830 * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
833 g_value_set_ulong (GValue
*value
,
836 g_return_if_fail (G_VALUE_HOLDS_ULONG (value
));
838 value
->data
[0].v_ulong
= v_ulong
;
843 * @value: a valid #GValue of type %G_TYPE_ULONG
845 * Get the contents of a %G_TYPE_ULONG #GValue.
847 * Returns: unsigned long integer contents of @value
850 g_value_get_ulong (const GValue
*value
)
852 g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value
), 0);
854 return value
->data
[0].v_ulong
;
859 * @value: a valid #GValue of type %G_TYPE_INT64
861 * Get the contents of a %G_TYPE_INT64 #GValue.
863 * Returns: 64bit integer contents of @value
866 g_value_set_int64 (GValue
*value
,
869 g_return_if_fail (G_VALUE_HOLDS_INT64 (value
));
871 value
->data
[0].v_int64
= v_int64
;
876 * @value: a valid #GValue of type %G_TYPE_INT64
877 * @v_int64: 64bit integer value to be set
879 * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
882 g_value_get_int64 (const GValue
*value
)
884 g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value
), 0);
886 return value
->data
[0].v_int64
;
890 * g_value_set_uint64:
891 * @value: a valid #GValue of type %G_TYPE_UINT64
892 * @v_uint64: unsigned 64bit integer value to be set
894 * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
897 g_value_set_uint64 (GValue
*value
,
900 g_return_if_fail (G_VALUE_HOLDS_UINT64 (value
));
902 value
->data
[0].v_uint64
= v_uint64
;
906 * g_value_get_uint64:
907 * @value: a valid #GValue of type %G_TYPE_UINT64
909 * Get the contents of a %G_TYPE_UINT64 #GValue.
911 * Returns: unsigned 64bit integer contents of @value
914 g_value_get_uint64 (const GValue
*value
)
916 g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value
), 0);
918 return value
->data
[0].v_uint64
;
923 * @value: a valid #GValue of type %G_TYPE_FLOAT
924 * @v_float: float value to be set
926 * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
929 g_value_set_float (GValue
*value
,
932 g_return_if_fail (G_VALUE_HOLDS_FLOAT (value
));
934 value
->data
[0].v_float
= v_float
;
939 * @value: a valid #GValue of type %G_TYPE_FLOAT
941 * Get the contents of a %G_TYPE_FLOAT #GValue.
943 * Returns: float contents of @value
946 g_value_get_float (const GValue
*value
)
948 g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value
), 0);
950 return value
->data
[0].v_float
;
954 * g_value_set_double:
955 * @value: a valid #GValue of type %G_TYPE_DOUBLE
956 * @v_double: double value to be set
958 * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
961 g_value_set_double (GValue
*value
,
964 g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value
));
966 value
->data
[0].v_double
= v_double
;
970 * g_value_get_double:
971 * @value: a valid #GValue of type %G_TYPE_DOUBLE
973 * Get the contents of a %G_TYPE_DOUBLE #GValue.
975 * Returns: double contents of @value
978 g_value_get_double (const GValue
*value
)
980 g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value
), 0);
982 return value
->data
[0].v_double
;
986 * g_value_set_string:
987 * @value: a valid #GValue of type %G_TYPE_STRING
988 * @v_string: caller-owned string to be duplicated for the #GValue
990 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
993 g_value_set_string (GValue
*value
,
994 const gchar
*v_string
)
998 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
1000 new_val
= g_strdup (v_string
);
1002 if (value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
)
1003 value
->data
[1].v_uint
= 0;
1005 g_free (value
->data
[0].v_pointer
);
1007 value
->data
[0].v_pointer
= new_val
;
1011 * g_value_set_static_string:
1012 * @value: a valid #GValue of type %G_TYPE_STRING
1013 * @v_string: static string to be set
1015 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1016 * The string is assumed to be static, and is thus not duplicated
1017 * when setting the #GValue.
1020 g_value_set_static_string (GValue
*value
,
1021 const gchar
*v_string
)
1023 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
1025 if (!(value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
))
1026 g_free (value
->data
[0].v_pointer
);
1027 value
->data
[1].v_uint
= G_VALUE_NOCOPY_CONTENTS
;
1028 value
->data
[0].v_pointer
= (gchar
*) v_string
;
1032 * g_value_set_string_take_ownership:
1033 * @value: a valid #GValue of type %G_TYPE_STRING
1034 * @v_string: duplicated unowned string to be set
1036 * This is an internal function introduced mainly for C marshallers.
1038 * Deprecated: 2.4: Use g_value_take_string() instead.
1041 g_value_set_string_take_ownership (GValue
*value
,
1044 g_value_take_string (value
, v_string
);
1048 * g_value_take_string:
1049 * @value: a valid #GValue of type %G_TYPE_STRING
1050 * @v_string: string to take ownership of
1052 * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1057 g_value_take_string (GValue
*value
,
1060 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
1062 if (value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
)
1063 value
->data
[1].v_uint
= 0;
1065 g_free (value
->data
[0].v_pointer
);
1066 value
->data
[0].v_pointer
= v_string
;
1070 * g_value_get_string:
1071 * @value: a valid #GValue of type %G_TYPE_STRING
1073 * Get the contents of a %G_TYPE_STRING #GValue.
1075 * Returns: string content of @value
1078 g_value_get_string (const GValue
*value
)
1080 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value
), NULL
);
1082 return value
->data
[0].v_pointer
;
1086 * g_value_dup_string:
1087 * @value: a valid #GValue of type %G_TYPE_STRING
1089 * Get a copy the contents of a %G_TYPE_STRING #GValue.
1091 * Returns: a newly allocated copy of the string content of @value
1094 g_value_dup_string (const GValue
*value
)
1096 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value
), NULL
);
1098 return g_strdup (value
->data
[0].v_pointer
);
1102 * g_value_set_pointer:
1103 * @value: a valid #GValue of %G_TYPE_POINTER
1104 * @v_pointer: pointer value to be set
1106 * Set the contents of a pointer #GValue to @v_pointer.
1109 g_value_set_pointer (GValue
*value
,
1112 g_return_if_fail (G_VALUE_HOLDS_POINTER (value
));
1114 value
->data
[0].v_pointer
= v_pointer
;
1118 * g_value_get_pointer:
1119 * @value: a valid #GValue of %G_TYPE_POINTER
1121 * Get the contents of a pointer #GValue.
1123 * Returns: (transfer none): pointer contents of @value
1126 g_value_get_pointer (const GValue
*value
)
1128 g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value
), NULL
);
1130 return value
->data
[0].v_pointer
;
1133 G_DEFINE_POINTER_TYPE (GType
, g_gtype
)
1136 * g_value_set_gtype:
1137 * @value: a valid #GValue of type %G_TYPE_GTYPE
1138 * @v_gtype: #GType to be set
1140 * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1145 g_value_set_gtype (GValue
*value
,
1148 g_return_if_fail (G_VALUE_HOLDS_GTYPE (value
));
1150 value
->data
[0].v_long
= v_gtype
;
1155 * g_value_get_gtype:
1156 * @value: a valid #GValue of type %G_TYPE_GTYPE
1158 * Get the contents of a %G_TYPE_GTYPE #GValue.
1162 * Returns: the #GType stored in @value
1165 g_value_get_gtype (const GValue
*value
)
1167 g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value
), 0);
1169 return value
->data
[0].v_long
;
1173 * g_value_set_variant:
1174 * @value: a valid #GValue of type %G_TYPE_VARIANT
1175 * @variant: a #GVariant, or %NULL
1177 * Set the contents of a variant #GValue to @variant.
1178 * If the variant is floating, it is consumed.
1183 g_value_set_variant (GValue
*value
,
1186 GVariant
*old_variant
;
1188 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value
));
1190 old_variant
= value
->data
[0].v_pointer
;
1193 value
->data
[0].v_pointer
= g_variant_ref_sink (variant
);
1195 value
->data
[0].v_pointer
= NULL
;
1198 g_variant_unref (old_variant
);
1202 * g_value_take_variant:
1203 * @value: a valid #GValue of type %G_TYPE_VARIANT
1204 * @variant: a #GVariant, or %NULL
1206 * Set the contents of a variant #GValue to @variant, and takes over
1207 * the ownership of the caller's reference to @variant;
1208 * the caller doesn't have to unref it any more (i.e. the reference
1209 * count of the variant is not increased).
1211 * It is a programmer error to pass a floating variant to this function.
1212 * In particular this means that callbacks in closures, and signal handlers
1213 * for signals of return type %G_TYPE_VARIANT, must never return floating
1216 * If you want the #GValue to hold its own reference to @variant, use
1217 * g_value_set_variant() instead.
1219 * This is an internal function introduced mainly for C marshallers.
1224 g_value_take_variant (GValue
*value
,
1227 GVariant
*old_variant
;
1229 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value
));
1230 g_return_if_fail (variant
== NULL
|| !g_variant_is_floating (variant
));
1232 old_variant
= value
->data
[0].v_pointer
;
1234 value
->data
[0].v_pointer
= variant
;
1237 g_variant_unref (old_variant
);
1241 * g_value_get_variant:
1242 * @value: a valid #GValue of type %G_TYPE_VARIANT
1244 * Get the contents of a variant #GValue.
1246 * Returns: variant contents of @value
1251 g_value_get_variant (const GValue
*value
)
1253 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value
), NULL
);
1255 return value
->data
[0].v_pointer
;
1259 * g_value_dup_variant:
1260 * @value: a valid #GValue of type %G_TYPE_VARIANT
1262 * Get the contents of a variant #GValue, increasing its refcount.
1264 * Returns: variant contents of @value, should be unrefed using
1265 * g_variant_unref() when no longer needed
1270 g_value_dup_variant (const GValue
*value
)
1274 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value
), NULL
);
1276 variant
= value
->data
[0].v_pointer
;
1278 g_variant_ref_sink (variant
);
1284 * g_strdup_value_contents:
1285 * @value: #GValue which contents are to be described.
1287 * Return a newly allocated string, which describes the contents of a
1288 * #GValue. The main purpose of this function is to describe #GValue
1289 * contents for debugging output, the way in which the contents are
1290 * described may change between different GLib versions.
1292 * Returns: Newly allocated string.
1295 g_strdup_value_contents (const GValue
*value
)
1300 g_return_val_if_fail (G_IS_VALUE (value
), NULL
);
1302 if (G_VALUE_HOLDS_STRING (value
))
1304 src
= g_value_get_string (value
);
1307 contents
= g_strdup ("NULL");
1310 gchar
*s
= g_strescape (src
, NULL
);
1312 contents
= g_strdup_printf ("\"%s\"", s
);
1316 else if (g_value_type_transformable (G_VALUE_TYPE (value
), G_TYPE_STRING
))
1318 GValue tmp_value
= { 0, };
1321 g_value_init (&tmp_value
, G_TYPE_STRING
);
1322 g_value_transform (value
, &tmp_value
);
1323 s
= g_strescape (g_value_get_string (&tmp_value
), NULL
);
1324 g_value_unset (&tmp_value
);
1325 if (G_VALUE_HOLDS_ENUM (value
) || G_VALUE_HOLDS_FLAGS (value
))
1326 contents
= g_strdup_printf ("((%s) %s)",
1327 g_type_name (G_VALUE_TYPE (value
)),
1330 contents
= g_strdup (s
? s
: "NULL");
1333 else if (g_value_fits_pointer (value
))
1335 gpointer p
= g_value_peek_pointer (value
);
1338 contents
= g_strdup ("NULL");
1339 else if (G_VALUE_HOLDS_OBJECT (value
))
1340 contents
= g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p
), p
);
1341 else if (G_VALUE_HOLDS_PARAM (value
))
1342 contents
= g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p
), p
);
1343 else if (G_VALUE_HOLDS (value
, G_TYPE_STRV
))
1345 GStrv strv
= g_value_get_boxed (value
);
1346 GString
*tmp
= g_string_new ("[");
1348 while (*strv
!= NULL
)
1350 gchar
*escaped
= g_strescape (*strv
, NULL
);
1352 g_string_append_printf (tmp
, "\"%s\"", escaped
);
1355 if (*++strv
!= NULL
)
1356 g_string_append (tmp
, ", ");
1359 g_string_append (tmp
, "]");
1360 contents
= g_string_free (tmp
, FALSE
);
1362 else if (G_VALUE_HOLDS_BOXED (value
))
1363 contents
= g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value
)), p
);
1364 else if (G_VALUE_HOLDS_POINTER (value
))
1365 contents
= g_strdup_printf ("((gpointer) %p)", p
);
1367 contents
= g_strdup ("???");
1370 contents
= g_strdup ("???");
1376 * g_pointer_type_register_static:
1377 * @name: the name of the new pointer type.
1379 * Creates a new %G_TYPE_POINTER derived type id for a new
1380 * pointer type with name @name.
1382 * Returns: a new %G_TYPE_POINTER derived type id for @name.
1385 g_pointer_type_register_static (const gchar
*name
)
1387 static const GTypeInfo type_info
= {
1389 NULL
, /* base_init */
1390 NULL
, /* base_finalize */
1391 NULL
, /* class_init */
1392 NULL
, /* class_finalize */
1393 NULL
, /* class_data */
1394 0, /* instance_size */
1395 0, /* n_preallocs */
1396 NULL
, /* instance_init */
1397 NULL
/* value_table */
1401 g_return_val_if_fail (name
!= NULL
, 0);
1402 g_return_val_if_fail (g_type_from_name (name
) == 0, 0);
1404 type
= g_type_register_static (G_TYPE_POINTER
, name
, &type_info
, 0);