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 "gvaluecollector.h"
38 /* --- value functions --- */
40 value_init_long0 (GValue
*value
)
42 value
->data
[0].v_long
= 0;
46 value_copy_long0 (const GValue
*src_value
,
49 dest_value
->data
[0].v_long
= src_value
->data
[0].v_long
;
53 value_lcopy_char (const GValue
*value
,
54 guint n_collect_values
,
55 GTypeCValue
*collect_values
,
58 gint8
*int8_p
= collect_values
[0].v_pointer
;
61 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
63 *int8_p
= value
->data
[0].v_int
;
69 value_lcopy_boolean (const GValue
*value
,
70 guint n_collect_values
,
71 GTypeCValue
*collect_values
,
74 gboolean
*bool_p
= collect_values
[0].v_pointer
;
77 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
79 *bool_p
= value
->data
[0].v_int
;
85 value_collect_int (GValue
*value
,
86 guint n_collect_values
,
87 GTypeCValue
*collect_values
,
90 value
->data
[0].v_int
= collect_values
[0].v_int
;
96 value_lcopy_int (const GValue
*value
,
97 guint n_collect_values
,
98 GTypeCValue
*collect_values
,
101 gint
*int_p
= collect_values
[0].v_pointer
;
104 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
106 *int_p
= value
->data
[0].v_int
;
112 value_collect_long (GValue
*value
,
113 guint n_collect_values
,
114 GTypeCValue
*collect_values
,
117 value
->data
[0].v_long
= collect_values
[0].v_long
;
123 value_lcopy_long (const GValue
*value
,
124 guint n_collect_values
,
125 GTypeCValue
*collect_values
,
128 glong
*long_p
= collect_values
[0].v_pointer
;
131 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
133 *long_p
= value
->data
[0].v_long
;
139 value_init_int64 (GValue
*value
)
141 value
->data
[0].v_int64
= 0;
145 value_copy_int64 (const GValue
*src_value
,
148 dest_value
->data
[0].v_int64
= src_value
->data
[0].v_int64
;
152 value_collect_int64 (GValue
*value
,
153 guint n_collect_values
,
154 GTypeCValue
*collect_values
,
157 value
->data
[0].v_int64
= collect_values
[0].v_int64
;
163 value_lcopy_int64 (const GValue
*value
,
164 guint n_collect_values
,
165 GTypeCValue
*collect_values
,
168 gint64
*int64_p
= collect_values
[0].v_pointer
;
171 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
173 *int64_p
= value
->data
[0].v_int64
;
179 value_init_float (GValue
*value
)
181 value
->data
[0].v_float
= 0.0;
185 value_copy_float (const GValue
*src_value
,
188 dest_value
->data
[0].v_float
= src_value
->data
[0].v_float
;
192 value_collect_float (GValue
*value
,
193 guint n_collect_values
,
194 GTypeCValue
*collect_values
,
197 value
->data
[0].v_float
= collect_values
[0].v_double
;
203 value_lcopy_float (const GValue
*value
,
204 guint n_collect_values
,
205 GTypeCValue
*collect_values
,
208 gfloat
*float_p
= collect_values
[0].v_pointer
;
211 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
213 *float_p
= value
->data
[0].v_float
;
219 value_init_double (GValue
*value
)
221 value
->data
[0].v_double
= 0.0;
225 value_copy_double (const GValue
*src_value
,
228 dest_value
->data
[0].v_double
= src_value
->data
[0].v_double
;
232 value_collect_double (GValue
*value
,
233 guint n_collect_values
,
234 GTypeCValue
*collect_values
,
237 value
->data
[0].v_double
= collect_values
[0].v_double
;
243 value_lcopy_double (const GValue
*value
,
244 guint n_collect_values
,
245 GTypeCValue
*collect_values
,
248 gdouble
*double_p
= collect_values
[0].v_pointer
;
251 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
253 *double_p
= value
->data
[0].v_double
;
259 value_init_string (GValue
*value
)
261 value
->data
[0].v_pointer
= NULL
;
265 value_free_string (GValue
*value
)
267 if (!(value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
))
268 g_free (value
->data
[0].v_pointer
);
272 value_copy_string (const GValue
*src_value
,
275 dest_value
->data
[0].v_pointer
= g_strdup (src_value
->data
[0].v_pointer
);
279 value_collect_string (GValue
*value
,
280 guint n_collect_values
,
281 GTypeCValue
*collect_values
,
284 if (!collect_values
[0].v_pointer
)
285 value
->data
[0].v_pointer
= NULL
;
286 else if (collect_flags
& G_VALUE_NOCOPY_CONTENTS
)
288 value
->data
[0].v_pointer
= collect_values
[0].v_pointer
;
289 value
->data
[1].v_uint
= G_VALUE_NOCOPY_CONTENTS
;
292 value
->data
[0].v_pointer
= g_strdup (collect_values
[0].v_pointer
);
298 value_lcopy_string (const GValue
*value
,
299 guint n_collect_values
,
300 GTypeCValue
*collect_values
,
303 gchar
**string_p
= collect_values
[0].v_pointer
;
306 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
308 if (!value
->data
[0].v_pointer
)
310 else if (collect_flags
& G_VALUE_NOCOPY_CONTENTS
)
311 *string_p
= value
->data
[0].v_pointer
;
313 *string_p
= g_strdup (value
->data
[0].v_pointer
);
319 value_init_pointer (GValue
*value
)
321 value
->data
[0].v_pointer
= NULL
;
325 value_copy_pointer (const GValue
*src_value
,
328 dest_value
->data
[0].v_pointer
= src_value
->data
[0].v_pointer
;
332 value_peek_pointer0 (const GValue
*value
)
334 return value
->data
[0].v_pointer
;
338 value_collect_pointer (GValue
*value
,
339 guint n_collect_values
,
340 GTypeCValue
*collect_values
,
343 value
->data
[0].v_pointer
= collect_values
[0].v_pointer
;
349 value_lcopy_pointer (const GValue
*value
,
350 guint n_collect_values
,
351 GTypeCValue
*collect_values
,
354 gpointer
*pointer_p
= collect_values
[0].v_pointer
;
357 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
359 *pointer_p
= value
->data
[0].v_pointer
;
365 value_free_variant (GValue
*value
)
367 if (!(value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
) &&
368 value
->data
[0].v_pointer
)
369 g_variant_unref (value
->data
[0].v_pointer
);
373 value_copy_variant (const GValue
*src_value
,
376 if (src_value
->data
[0].v_pointer
)
377 dest_value
->data
[0].v_pointer
= g_variant_ref_sink (src_value
->data
[0].v_pointer
);
379 dest_value
->data
[0].v_pointer
= NULL
;
383 value_collect_variant (GValue
*value
,
384 guint n_collect_values
,
385 GTypeCValue
*collect_values
,
388 if (!collect_values
[0].v_pointer
)
389 value
->data
[0].v_pointer
= NULL
;
390 else if (collect_flags
& G_VALUE_NOCOPY_CONTENTS
)
392 value
->data
[0].v_pointer
= collect_values
[0].v_pointer
;
393 value
->data
[1].v_uint
= G_VALUE_NOCOPY_CONTENTS
;
396 value
->data
[0].v_pointer
= g_variant_ref_sink (collect_values
[0].v_pointer
);
402 value_lcopy_variant (const GValue
*value
,
403 guint n_collect_values
,
404 GTypeCValue
*collect_values
,
407 GVariant
**variant_p
= collect_values
[0].v_pointer
;
410 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value
));
412 if (!value
->data
[0].v_pointer
)
414 else if (collect_flags
& G_VALUE_NOCOPY_CONTENTS
)
415 *variant_p
= value
->data
[0].v_pointer
;
417 *variant_p
= g_variant_ref_sink (value
->data
[0].v_pointer
);
422 /* --- type initialization --- */
424 g_value_types_init (void)
428 NULL
, /* base_init */
429 NULL
, /* base_destroy */
430 NULL
, /* class_init */
431 NULL
, /* class_destroy */
432 NULL
, /* class_data */
433 0, /* instance_size */
435 NULL
, /* instance_init */
436 NULL
, /* value_table */
438 const GTypeFundamentalInfo finfo
= { G_TYPE_FLAG_DERIVABLE
, };
441 /* G_TYPE_CHAR / G_TYPE_UCHAR
444 static const GTypeValueTable value_table
= {
445 value_init_long0
, /* value_init */
446 NULL
, /* value_free */
447 value_copy_long0
, /* value_copy */
448 NULL
, /* value_peek_pointer */
449 "i", /* collect_format */
450 value_collect_int
, /* collect_value */
451 "p", /* lcopy_format */
452 value_lcopy_char
, /* lcopy_value */
454 info
.value_table
= &value_table
;
455 type
= g_type_register_fundamental (G_TYPE_CHAR
, g_intern_static_string ("gchar"), &info
, &finfo
, 0);
456 g_assert (type
== G_TYPE_CHAR
);
457 type
= g_type_register_fundamental (G_TYPE_UCHAR
, g_intern_static_string ("guchar"), &info
, &finfo
, 0);
458 g_assert (type
== G_TYPE_UCHAR
);
464 static const GTypeValueTable value_table
= {
465 value_init_long0
, /* value_init */
466 NULL
, /* value_free */
467 value_copy_long0
, /* value_copy */
468 NULL
, /* value_peek_pointer */
469 "i", /* collect_format */
470 value_collect_int
, /* collect_value */
471 "p", /* lcopy_format */
472 value_lcopy_boolean
, /* lcopy_value */
474 info
.value_table
= &value_table
;
475 type
= g_type_register_fundamental (G_TYPE_BOOLEAN
, g_intern_static_string ("gboolean"), &info
, &finfo
, 0);
476 g_assert (type
== G_TYPE_BOOLEAN
);
479 /* G_TYPE_INT / G_TYPE_UINT
482 static const GTypeValueTable value_table
= {
483 value_init_long0
, /* value_init */
484 NULL
, /* value_free */
485 value_copy_long0
, /* value_copy */
486 NULL
, /* value_peek_pointer */
487 "i", /* collect_format */
488 value_collect_int
, /* collect_value */
489 "p", /* lcopy_format */
490 value_lcopy_int
, /* lcopy_value */
492 info
.value_table
= &value_table
;
493 type
= g_type_register_fundamental (G_TYPE_INT
, g_intern_static_string ("gint"), &info
, &finfo
, 0);
494 g_assert (type
== G_TYPE_INT
);
495 type
= g_type_register_fundamental (G_TYPE_UINT
, g_intern_static_string ("guint"), &info
, &finfo
, 0);
496 g_assert (type
== G_TYPE_UINT
);
499 /* G_TYPE_LONG / G_TYPE_ULONG
502 static const GTypeValueTable value_table
= {
503 value_init_long0
, /* value_init */
504 NULL
, /* value_free */
505 value_copy_long0
, /* value_copy */
506 NULL
, /* value_peek_pointer */
507 "l", /* collect_format */
508 value_collect_long
, /* collect_value */
509 "p", /* lcopy_format */
510 value_lcopy_long
, /* lcopy_value */
512 info
.value_table
= &value_table
;
513 type
= g_type_register_fundamental (G_TYPE_LONG
, g_intern_static_string ("glong"), &info
, &finfo
, 0);
514 g_assert (type
== G_TYPE_LONG
);
515 type
= g_type_register_fundamental (G_TYPE_ULONG
, g_intern_static_string ("gulong"), &info
, &finfo
, 0);
516 g_assert (type
== G_TYPE_ULONG
);
519 /* G_TYPE_INT64 / G_TYPE_UINT64
522 static const GTypeValueTable value_table
= {
523 value_init_int64
, /* value_init */
524 NULL
, /* value_free */
525 value_copy_int64
, /* value_copy */
526 NULL
, /* value_peek_pointer */
527 "q", /* collect_format */
528 value_collect_int64
, /* collect_value */
529 "p", /* lcopy_format */
530 value_lcopy_int64
, /* lcopy_value */
532 info
.value_table
= &value_table
;
533 type
= g_type_register_fundamental (G_TYPE_INT64
, g_intern_static_string ("gint64"), &info
, &finfo
, 0);
534 g_assert (type
== G_TYPE_INT64
);
535 type
= g_type_register_fundamental (G_TYPE_UINT64
, g_intern_static_string ("guint64"), &info
, &finfo
, 0);
536 g_assert (type
== G_TYPE_UINT64
);
542 static const GTypeValueTable value_table
= {
543 value_init_float
, /* value_init */
544 NULL
, /* value_free */
545 value_copy_float
, /* value_copy */
546 NULL
, /* value_peek_pointer */
547 "d", /* collect_format */
548 value_collect_float
, /* collect_value */
549 "p", /* lcopy_format */
550 value_lcopy_float
, /* lcopy_value */
552 info
.value_table
= &value_table
;
553 type
= g_type_register_fundamental (G_TYPE_FLOAT
, g_intern_static_string ("gfloat"), &info
, &finfo
, 0);
554 g_assert (type
== G_TYPE_FLOAT
);
560 static const GTypeValueTable value_table
= {
561 value_init_double
, /* value_init */
562 NULL
, /* value_free */
563 value_copy_double
, /* value_copy */
564 NULL
, /* value_peek_pointer */
565 "d", /* collect_format */
566 value_collect_double
, /* collect_value */
567 "p", /* lcopy_format */
568 value_lcopy_double
, /* lcopy_value */
570 info
.value_table
= &value_table
;
571 type
= g_type_register_fundamental (G_TYPE_DOUBLE
, g_intern_static_string ("gdouble"), &info
, &finfo
, 0);
572 g_assert (type
== G_TYPE_DOUBLE
);
578 static const GTypeValueTable value_table
= {
579 value_init_string
, /* value_init */
580 value_free_string
, /* value_free */
581 value_copy_string
, /* value_copy */
582 value_peek_pointer0
, /* value_peek_pointer */
583 "p", /* collect_format */
584 value_collect_string
, /* collect_value */
585 "p", /* lcopy_format */
586 value_lcopy_string
, /* lcopy_value */
588 info
.value_table
= &value_table
;
589 type
= g_type_register_fundamental (G_TYPE_STRING
, g_intern_static_string ("gchararray"), &info
, &finfo
, 0);
590 g_assert (type
== G_TYPE_STRING
);
596 static const GTypeValueTable value_table
= {
597 value_init_pointer
, /* value_init */
598 NULL
, /* value_free */
599 value_copy_pointer
, /* value_copy */
600 value_peek_pointer0
, /* value_peek_pointer */
601 "p", /* collect_format */
602 value_collect_pointer
, /* collect_value */
603 "p", /* lcopy_format */
604 value_lcopy_pointer
, /* lcopy_value */
606 info
.value_table
= &value_table
;
607 type
= g_type_register_fundamental (G_TYPE_POINTER
, g_intern_static_string ("gpointer"), &info
, &finfo
, 0);
608 g_assert (type
== G_TYPE_POINTER
);
614 static const GTypeValueTable value_table
= {
615 value_init_pointer
, /* value_init */
616 value_free_variant
, /* value_free */
617 value_copy_variant
, /* value_copy */
618 value_peek_pointer0
, /* value_peek_pointer */
619 "p", /* collect_format */
620 value_collect_variant
, /* collect_value */
621 "p", /* lcopy_format */
622 value_lcopy_variant
, /* lcopy_value */
624 info
.value_table
= &value_table
;
625 type
= g_type_register_fundamental (G_TYPE_VARIANT
, g_intern_static_string ("GVariant"), &info
, &finfo
, 0);
626 g_assert (type
== G_TYPE_VARIANT
);
631 /* --- GValue functions --- */
634 * @value: a valid #GValue of type %G_TYPE_CHAR
635 * @v_char: character value to be set
637 * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
640 g_value_set_char (GValue
*value
,
643 g_return_if_fail (G_VALUE_HOLDS_CHAR (value
));
645 value
->data
[0].v_int
= v_char
;
650 * @value: a valid #GValue of type %G_TYPE_CHAR
652 * Get the contents of a %G_TYPE_CHAR #GValue.
654 * Returns: character contents of @value
657 g_value_get_char (const GValue
*value
)
659 g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value
), 0);
661 return value
->data
[0].v_int
;
666 * @value: a valid #GValue of type %G_TYPE_UCHAR
667 * @v_uchar: unsigned character value to be set
669 * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
672 g_value_set_uchar (GValue
*value
,
675 g_return_if_fail (G_VALUE_HOLDS_UCHAR (value
));
677 value
->data
[0].v_uint
= v_uchar
;
682 * @value: a valid #GValue of type %G_TYPE_UCHAR
684 * Get the contents of a %G_TYPE_UCHAR #GValue.
686 * Returns: unsigned character contents of @value
689 g_value_get_uchar (const GValue
*value
)
691 g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value
), 0);
693 return value
->data
[0].v_uint
;
697 * g_value_set_boolean:
698 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
699 * @v_boolean: boolean value to be set
701 * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
704 g_value_set_boolean (GValue
*value
,
707 g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value
));
709 value
->data
[0].v_int
= v_boolean
!= FALSE
;
713 * g_value_get_boolean:
714 * @value: a valid #GValue of type %G_TYPE_BOOLEAN
716 * Get the contents of a %G_TYPE_BOOLEAN #GValue.
718 * Returns: boolean contents of @value
721 g_value_get_boolean (const GValue
*value
)
723 g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value
), 0);
725 return value
->data
[0].v_int
;
730 * @value: a valid #GValue of type %G_TYPE_INT
731 * @v_int: integer value to be set
733 * Set the contents of a %G_TYPE_INT #GValue to @v_int.
736 g_value_set_int (GValue
*value
,
739 g_return_if_fail (G_VALUE_HOLDS_INT (value
));
741 value
->data
[0].v_int
= v_int
;
746 * @value: a valid #GValue of type %G_TYPE_INT
748 * Get the contents of a %G_TYPE_INT #GValue.
750 * Returns: integer contents of @value
753 g_value_get_int (const GValue
*value
)
755 g_return_val_if_fail (G_VALUE_HOLDS_INT (value
), 0);
757 return value
->data
[0].v_int
;
762 * @value: a valid #GValue of type %G_TYPE_UINT
763 * @v_uint: unsigned integer value to be set
765 * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
768 g_value_set_uint (GValue
*value
,
771 g_return_if_fail (G_VALUE_HOLDS_UINT (value
));
773 value
->data
[0].v_uint
= v_uint
;
778 * @value: a valid #GValue of type %G_TYPE_UINT
780 * Get the contents of a %G_TYPE_UINT #GValue.
782 * Returns: unsigned integer contents of @value
785 g_value_get_uint (const GValue
*value
)
787 g_return_val_if_fail (G_VALUE_HOLDS_UINT (value
), 0);
789 return value
->data
[0].v_uint
;
794 * @value: a valid #GValue of type %G_TYPE_LONG
795 * @v_long: long integer value to be set
797 * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
800 g_value_set_long (GValue
*value
,
803 g_return_if_fail (G_VALUE_HOLDS_LONG (value
));
805 value
->data
[0].v_long
= v_long
;
810 * @value: a valid #GValue of type %G_TYPE_LONG
812 * Get the contents of a %G_TYPE_LONG #GValue.
814 * Returns: long integer contents of @value
817 g_value_get_long (const GValue
*value
)
819 g_return_val_if_fail (G_VALUE_HOLDS_LONG (value
), 0);
821 return value
->data
[0].v_long
;
826 * @value: a valid #GValue of type %G_TYPE_ULONG
827 * @v_ulong: unsigned long integer value to be set
829 * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
832 g_value_set_ulong (GValue
*value
,
835 g_return_if_fail (G_VALUE_HOLDS_ULONG (value
));
837 value
->data
[0].v_ulong
= v_ulong
;
842 * @value: a valid #GValue of type %G_TYPE_ULONG
844 * Get the contents of a %G_TYPE_ULONG #GValue.
846 * Returns: unsigned long integer contents of @value
849 g_value_get_ulong (const GValue
*value
)
851 g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value
), 0);
853 return value
->data
[0].v_ulong
;
858 * @value: a valid #GValue of type %G_TYPE_INT64
860 * Get the contents of a %G_TYPE_INT64 #GValue.
862 * Returns: 64bit integer contents of @value
865 g_value_set_int64 (GValue
*value
,
868 g_return_if_fail (G_VALUE_HOLDS_INT64 (value
));
870 value
->data
[0].v_int64
= v_int64
;
875 * @value: a valid #GValue of type %G_TYPE_INT64
876 * @v_int64: 64bit integer value to be set
878 * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
881 g_value_get_int64 (const GValue
*value
)
883 g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value
), 0);
885 return value
->data
[0].v_int64
;
889 * g_value_set_uint64:
890 * @value: a valid #GValue of type %G_TYPE_UINT64
891 * @v_uint64: unsigned 64bit integer value to be set
893 * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
896 g_value_set_uint64 (GValue
*value
,
899 g_return_if_fail (G_VALUE_HOLDS_UINT64 (value
));
901 value
->data
[0].v_uint64
= v_uint64
;
905 * g_value_get_uint64:
906 * @value: a valid #GValue of type %G_TYPE_UINT64
908 * Get the contents of a %G_TYPE_UINT64 #GValue.
910 * Returns: unsigned 64bit integer contents of @value
913 g_value_get_uint64 (const GValue
*value
)
915 g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value
), 0);
917 return value
->data
[0].v_uint64
;
922 * @value: a valid #GValue of type %G_TYPE_FLOAT
923 * @v_float: float value to be set
925 * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
928 g_value_set_float (GValue
*value
,
931 g_return_if_fail (G_VALUE_HOLDS_FLOAT (value
));
933 value
->data
[0].v_float
= v_float
;
938 * @value: a valid #GValue of type %G_TYPE_FLOAT
940 * Get the contents of a %G_TYPE_FLOAT #GValue.
942 * Returns: float contents of @value
945 g_value_get_float (const GValue
*value
)
947 g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value
), 0);
949 return value
->data
[0].v_float
;
953 * g_value_set_double:
954 * @value: a valid #GValue of type %G_TYPE_DOUBLE
955 * @v_double: double value to be set
957 * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
960 g_value_set_double (GValue
*value
,
963 g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value
));
965 value
->data
[0].v_double
= v_double
;
969 * g_value_get_double:
970 * @value: a valid #GValue of type %G_TYPE_DOUBLE
972 * Get the contents of a %G_TYPE_DOUBLE #GValue.
974 * Returns: double contents of @value
977 g_value_get_double (const GValue
*value
)
979 g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value
), 0);
981 return value
->data
[0].v_double
;
985 * g_value_set_string:
986 * @value: a valid #GValue of type %G_TYPE_STRING
987 * @v_string: caller-owned string to be duplicated for the #GValue
989 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
992 g_value_set_string (GValue
*value
,
993 const gchar
*v_string
)
997 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
999 new_val
= g_strdup (v_string
);
1001 if (value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
)
1002 value
->data
[1].v_uint
= 0;
1004 g_free (value
->data
[0].v_pointer
);
1006 value
->data
[0].v_pointer
= new_val
;
1010 * g_value_set_static_string:
1011 * @value: a valid #GValue of type %G_TYPE_STRING
1012 * @v_string: static string to be set
1014 * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1015 * The string is assumed to be static, and is thus not duplicated
1016 * when setting the #GValue.
1019 g_value_set_static_string (GValue
*value
,
1020 const gchar
*v_string
)
1022 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
1024 if (!(value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
))
1025 g_free (value
->data
[0].v_pointer
);
1026 value
->data
[1].v_uint
= G_VALUE_NOCOPY_CONTENTS
;
1027 value
->data
[0].v_pointer
= (gchar
*) v_string
;
1031 * g_value_set_string_take_ownership:
1032 * @value: a valid #GValue of type %G_TYPE_STRING
1033 * @v_string: duplicated unowned string to be set
1035 * This is an internal function introduced mainly for C marshallers.
1037 * Deprecated: 2.4: Use g_value_take_string() instead.
1040 g_value_set_string_take_ownership (GValue
*value
,
1043 g_value_take_string (value
, v_string
);
1047 * g_value_take_string:
1048 * @value: a valid #GValue of type %G_TYPE_STRING
1049 * @v_string: string to take ownership of
1051 * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1056 g_value_take_string (GValue
*value
,
1059 g_return_if_fail (G_VALUE_HOLDS_STRING (value
));
1061 if (value
->data
[1].v_uint
& G_VALUE_NOCOPY_CONTENTS
)
1062 value
->data
[1].v_uint
= 0;
1064 g_free (value
->data
[0].v_pointer
);
1065 value
->data
[0].v_pointer
= v_string
;
1069 * g_value_get_string:
1070 * @value: a valid #GValue of type %G_TYPE_STRING
1072 * Get the contents of a %G_TYPE_STRING #GValue.
1074 * Returns: string content of @value
1076 G_CONST_RETURN gchar
*
1077 g_value_get_string (const GValue
*value
)
1079 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value
), NULL
);
1081 return value
->data
[0].v_pointer
;
1085 * g_value_dup_string:
1086 * @value: a valid #GValue of type %G_TYPE_STRING
1088 * Get a copy the contents of a %G_TYPE_STRING #GValue.
1090 * Returns: a newly allocated copy of the string content of @value
1093 g_value_dup_string (const GValue
*value
)
1095 g_return_val_if_fail (G_VALUE_HOLDS_STRING (value
), NULL
);
1097 return g_strdup (value
->data
[0].v_pointer
);
1101 * g_value_set_pointer:
1102 * @value: a valid #GValue of %G_TYPE_POINTER
1103 * @v_pointer: pointer value to be set
1105 * Set the contents of a pointer #GValue to @v_pointer.
1108 g_value_set_pointer (GValue
*value
,
1111 g_return_if_fail (G_VALUE_HOLDS_POINTER (value
));
1113 value
->data
[0].v_pointer
= v_pointer
;
1117 * g_value_get_pointer:
1118 * @value: a valid #GValue of %G_TYPE_POINTER
1120 * Get the contents of a pointer #GValue.
1122 * Returns: pointer contents of @value
1125 g_value_get_pointer (const GValue
*value
)
1127 g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value
), NULL
);
1129 return value
->data
[0].v_pointer
;
1132 G_DEFINE_POINTER_TYPE (GType
, g_gtype
)
1135 * g_value_set_gtype:
1136 * @value: a valid #GValue of type %G_TYPE_GTYPE
1137 * @v_gtype: #GType to be set
1139 * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1144 g_value_set_gtype (GValue
*value
,
1147 g_return_if_fail (G_VALUE_HOLDS_GTYPE (value
));
1149 value
->data
[0].v_long
= v_gtype
;
1154 * g_value_get_gtype:
1155 * @value: a valid #GValue of type %G_TYPE_GTYPE
1157 * Get the contents of a %G_TYPE_GTYPE #GValue.
1161 * Returns: the #GType stored in @value
1164 g_value_get_gtype (const GValue
*value
)
1166 g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value
), 0);
1168 return value
->data
[0].v_long
;
1172 * g_value_set_variant:
1173 * @value: a valid #GValue of type %G_TYPE_VARIANT
1174 * @variant: a #GVariant, or %NULL
1176 * Set the contents of a variant #GValue to @variant.
1177 * If the variant is floating, it is consumed.
1182 g_value_set_variant (GValue
*value
,
1185 GVariant
*old_variant
;
1187 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value
));
1189 old_variant
= value
->data
[0].v_pointer
;
1192 value
->data
[0].v_pointer
= g_variant_ref_sink (variant
);
1194 value
->data
[0].v_pointer
= NULL
;
1197 g_variant_unref (old_variant
);
1201 * g_value_take_variant:
1202 * @value: a valid #GValue of type %G_TYPE_VARIANT
1203 * @variant: a #GVariant, or %NULL
1205 * Set the contents of a variant #GValue to @variant, and takes over
1206 * the ownership of the caller's reference to @variant;
1207 * the caller doesn't have to unref it any more (i.e. the reference
1208 * count of the variant is not increased).
1210 * It is a programmer error to pass a floating variant to this function.
1211 * In particular this means that callbacks in closures, and signal handlers
1212 * for signals of return type %G_TYPE_VARIANT, must never return floating
1215 * If you want the #GValue to hold its own reference to @variant, use
1216 * g_value_set_variant() instead.
1218 * This is an internal function introduced mainly for C marshallers.
1223 g_value_take_variant (GValue
*value
,
1226 GVariant
*old_variant
;
1228 g_return_if_fail (G_VALUE_HOLDS_VARIANT (value
));
1229 g_return_if_fail (variant
== NULL
|| !g_variant_is_floating (variant
));
1231 old_variant
= value
->data
[0].v_pointer
;
1233 value
->data
[0].v_pointer
= variant
;
1236 g_variant_unref (old_variant
);
1240 * g_value_get_variant:
1241 * @value: a valid #GValue of type %G_TYPE_VARIANT
1243 * Get the contents of a variant #GValue.
1245 * Returns: variant contents of @value
1250 g_value_get_variant (const GValue
*value
)
1252 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value
), NULL
);
1254 return value
->data
[0].v_pointer
;
1258 * g_value_dup_variant:
1259 * @value: a valid #GValue of type %G_TYPE_VARIANT
1261 * Get the contents of a variant #GValue, increasing its refcount.
1263 * Returns: variant contents of @value, should be unrefed using
1264 * g_variant_unref() when no longer needed
1269 g_value_dup_variant (const GValue
*value
)
1273 g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value
), NULL
);
1275 variant
= value
->data
[0].v_pointer
;
1277 g_variant_ref_sink (variant
);
1283 * g_strdup_value_contents:
1284 * @value: #GValue which contents are to be described.
1286 * Return a newly allocated string, which describes the contents of a
1287 * #GValue. The main purpose of this function is to describe #GValue
1288 * contents for debugging output, the way in which the contents are
1289 * described may change between different GLib versions.
1291 * Returns: Newly allocated string.
1294 g_strdup_value_contents (const GValue
*value
)
1299 g_return_val_if_fail (G_IS_VALUE (value
), NULL
);
1301 if (G_VALUE_HOLDS_STRING (value
))
1303 src
= g_value_get_string (value
);
1306 contents
= g_strdup ("NULL");
1309 gchar
*s
= g_strescape (src
, NULL
);
1311 contents
= g_strdup_printf ("\"%s\"", s
);
1315 else if (g_value_type_transformable (G_VALUE_TYPE (value
), G_TYPE_STRING
))
1317 GValue tmp_value
= { 0, };
1320 g_value_init (&tmp_value
, G_TYPE_STRING
);
1321 g_value_transform (value
, &tmp_value
);
1322 s
= g_strescape (g_value_get_string (&tmp_value
), NULL
);
1323 g_value_unset (&tmp_value
);
1324 if (G_VALUE_HOLDS_ENUM (value
) || G_VALUE_HOLDS_FLAGS (value
))
1325 contents
= g_strdup_printf ("((%s) %s)",
1326 g_type_name (G_VALUE_TYPE (value
)),
1329 contents
= g_strdup (s
? s
: "NULL");
1332 else if (g_value_fits_pointer (value
))
1334 gpointer p
= g_value_peek_pointer (value
);
1337 contents
= g_strdup ("NULL");
1338 else if (G_VALUE_HOLDS_OBJECT (value
))
1339 contents
= g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p
), p
);
1340 else if (G_VALUE_HOLDS_PARAM (value
))
1341 contents
= g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p
), p
);
1342 else if (G_VALUE_HOLDS (value
, G_TYPE_STRV
))
1344 GStrv strv
= g_value_get_boxed (value
);
1345 GString
*tmp
= g_string_new ("[");
1347 while (*strv
!= NULL
)
1349 gchar
*escaped
= g_strescape (*strv
, NULL
);
1351 g_string_append_printf (tmp
, "\"%s\"", escaped
);
1354 if (*++strv
!= NULL
)
1355 g_string_append (tmp
, ", ");
1358 g_string_append (tmp
, "]");
1359 contents
= g_string_free (tmp
, FALSE
);
1361 else if (G_VALUE_HOLDS_BOXED (value
))
1362 contents
= g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value
)), p
);
1363 else if (G_VALUE_HOLDS_POINTER (value
))
1364 contents
= g_strdup_printf ("((gpointer) %p)", p
);
1366 contents
= g_strdup ("???");
1369 contents
= g_strdup ("???");
1375 * g_pointer_type_register_static:
1376 * @name: the name of the new pointer type.
1378 * Creates a new %G_TYPE_POINTER derived type id for a new
1379 * pointer type with name @name.
1381 * Returns: a new %G_TYPE_POINTER derived type id for @name.
1384 g_pointer_type_register_static (const gchar
*name
)
1386 static const GTypeInfo type_info
= {
1388 NULL
, /* base_init */
1389 NULL
, /* base_finalize */
1390 NULL
, /* class_init */
1391 NULL
, /* class_finalize */
1392 NULL
, /* class_data */
1393 0, /* instance_size */
1394 0, /* n_preallocs */
1395 NULL
, /* instance_init */
1396 NULL
/* value_table */
1400 g_return_val_if_fail (name
!= NULL
, 0);
1401 g_return_val_if_fail (g_type_from_name (name
) == 0, 0);
1403 type
= g_type_register_static (G_TYPE_POINTER
, name
, &type_info
, 0);