Branch data Line data Source code
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
4 : : *
5 : : * SPDX-License-Identifier: LGPL-2.1-or-later
6 : : *
7 : : * This library is free software; you can redistribute it and/or
8 : : * modify it under the terms of the GNU Lesser General Public
9 : : * License as published by the Free Software Foundation; either
10 : : * version 2.1 of the License, or (at your option) any later version.
11 : : *
12 : : * This library is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : * Lesser General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU Lesser General
18 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 : : */
20 : :
21 : : /*
22 : : * MT safe
23 : : */
24 : :
25 : : #include "config.h"
26 : :
27 : : #include <string.h>
28 : : #include <stdlib.h> /* qsort() */
29 : :
30 : : #include "gvaluetypes.h"
31 : : #include "gtype-private.h"
32 : : #include "gvaluecollector.h"
33 : : #include "gobject.h"
34 : : #include "gparam.h"
35 : : #include "gboxed.h"
36 : : #include "genums.h"
37 : :
38 : :
39 : : /* --- value functions --- */
40 : : static void
41 : 11243864 : value_init_long0 (GValue *value)
42 : : {
43 : 11243864 : value->data[0].v_long = 0;
44 : 11243864 : }
45 : :
46 : : static void
47 : 679 : value_copy_long0 (const GValue *src_value,
48 : : GValue *dest_value)
49 : : {
50 : 679 : dest_value->data[0].v_long = src_value->data[0].v_long;
51 : 679 : }
52 : :
53 : : static gchar*
54 : 6 : value_lcopy_char (const GValue *value,
55 : : guint n_collect_values,
56 : : GTypeCValue *collect_values,
57 : : guint collect_flags)
58 : : {
59 : 6 : gint8 *int8_p = collect_values[0].v_pointer;
60 : :
61 : 6 : g_return_val_if_fail (int8_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
62 : :
63 : 6 : *int8_p = value->data[0].v_int;
64 : :
65 : 6 : return NULL;
66 : : }
67 : :
68 : : static gchar*
69 : 1776 : value_lcopy_boolean (const GValue *value,
70 : : guint n_collect_values,
71 : : GTypeCValue *collect_values,
72 : : guint collect_flags)
73 : : {
74 : 1776 : gboolean *bool_p = collect_values[0].v_pointer;
75 : :
76 : 1776 : g_return_val_if_fail (bool_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
77 : :
78 : 1776 : *bool_p = value->data[0].v_int;
79 : :
80 : 1776 : return NULL;
81 : : }
82 : :
83 : : static gchar*
84 : 14892210 : value_collect_int (GValue *value,
85 : : guint n_collect_values,
86 : : GTypeCValue *collect_values,
87 : : guint collect_flags)
88 : : {
89 : 14892210 : value->data[0].v_int = collect_values[0].v_int;
90 : :
91 : 14892210 : return NULL;
92 : : }
93 : :
94 : : static gchar*
95 : 11218810 : value_lcopy_int (const GValue *value,
96 : : guint n_collect_values,
97 : : GTypeCValue *collect_values,
98 : : guint collect_flags)
99 : : {
100 : 11218810 : gint *int_p = collect_values[0].v_pointer;
101 : :
102 : 11218810 : g_return_val_if_fail (int_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
103 : :
104 : 11218810 : *int_p = value->data[0].v_int;
105 : :
106 : 11218810 : return NULL;
107 : : }
108 : :
109 : : static gchar*
110 : 1179 : value_collect_long (GValue *value,
111 : : guint n_collect_values,
112 : : GTypeCValue *collect_values,
113 : : guint collect_flags)
114 : : {
115 : 1179 : value->data[0].v_long = collect_values[0].v_long;
116 : :
117 : 1179 : return NULL;
118 : : }
119 : :
120 : : static gchar*
121 : 4 : value_lcopy_long (const GValue *value,
122 : : guint n_collect_values,
123 : : GTypeCValue *collect_values,
124 : : guint collect_flags)
125 : : {
126 : 4 : glong *long_p = collect_values[0].v_pointer;
127 : :
128 : 4 : g_return_val_if_fail (long_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
129 : :
130 : 4 : *long_p = value->data[0].v_long;
131 : :
132 : 4 : return NULL;
133 : : }
134 : :
135 : : static void
136 : 213 : value_init_int64 (GValue *value)
137 : : {
138 : 213 : value->data[0].v_int64 = 0;
139 : 213 : }
140 : :
141 : : static void
142 : 44 : value_copy_int64 (const GValue *src_value,
143 : : GValue *dest_value)
144 : : {
145 : 44 : dest_value->data[0].v_int64 = src_value->data[0].v_int64;
146 : 44 : }
147 : :
148 : : static gchar*
149 : 27 : value_collect_int64 (GValue *value,
150 : : guint n_collect_values,
151 : : GTypeCValue *collect_values,
152 : : guint collect_flags)
153 : : {
154 : 27 : value->data[0].v_int64 = collect_values[0].v_int64;
155 : :
156 : 27 : return NULL;
157 : : }
158 : :
159 : : static gchar*
160 : 11 : value_lcopy_int64 (const GValue *value,
161 : : guint n_collect_values,
162 : : GTypeCValue *collect_values,
163 : : guint collect_flags)
164 : : {
165 : 11 : gint64 *int64_p = collect_values[0].v_pointer;
166 : :
167 : 11 : g_return_val_if_fail (int64_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
168 : :
169 : 11 : *int64_p = value->data[0].v_int64;
170 : :
171 : 11 : return NULL;
172 : : }
173 : :
174 : : static void
175 : 29 : value_init_float (GValue *value)
176 : : {
177 : 29 : value->data[0].v_float = 0.0;
178 : 29 : }
179 : :
180 : : static void
181 : 1 : value_copy_float (const GValue *src_value,
182 : : GValue *dest_value)
183 : : {
184 : 1 : dest_value->data[0].v_float = src_value->data[0].v_float;
185 : 1 : }
186 : :
187 : : static gchar*
188 : 12 : value_collect_float (GValue *value,
189 : : guint n_collect_values,
190 : : GTypeCValue *collect_values,
191 : : guint collect_flags)
192 : : {
193 : : /* This necessarily loses precision */
194 : 12 : value->data[0].v_float = (gfloat) collect_values[0].v_double;
195 : :
196 : 12 : return NULL;
197 : : }
198 : :
199 : : static gchar*
200 : 1 : value_lcopy_float (const GValue *value,
201 : : guint n_collect_values,
202 : : GTypeCValue *collect_values,
203 : : guint collect_flags)
204 : : {
205 : 1 : gfloat *float_p = collect_values[0].v_pointer;
206 : :
207 : 1 : g_return_val_if_fail (float_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
208 : :
209 : 1 : *float_p = value->data[0].v_float;
210 : :
211 : 1 : return NULL;
212 : : }
213 : :
214 : : static void
215 : 335 : value_init_double (GValue *value)
216 : : {
217 : 335 : value->data[0].v_double = 0.0;
218 : 335 : }
219 : :
220 : : static void
221 : 107 : value_copy_double (const GValue *src_value,
222 : : GValue *dest_value)
223 : : {
224 : 107 : dest_value->data[0].v_double = src_value->data[0].v_double;
225 : 107 : }
226 : :
227 : : static gchar*
228 : 43 : value_collect_double (GValue *value,
229 : : guint n_collect_values,
230 : : GTypeCValue *collect_values,
231 : : guint collect_flags)
232 : : {
233 : 43 : value->data[0].v_double = collect_values[0].v_double;
234 : :
235 : 43 : return NULL;
236 : : }
237 : :
238 : : static gchar*
239 : 9 : value_lcopy_double (const GValue *value,
240 : : guint n_collect_values,
241 : : GTypeCValue *collect_values,
242 : : guint collect_flags)
243 : : {
244 : 9 : gdouble *double_p = collect_values[0].v_pointer;
245 : :
246 : 9 : g_return_val_if_fail (double_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
247 : :
248 : 9 : *double_p = value->data[0].v_double;
249 : :
250 : 9 : return NULL;
251 : : }
252 : :
253 : : static void
254 : 967855 : value_init_string (GValue *value)
255 : : {
256 : 967855 : value->data[0].v_pointer = NULL;
257 : 967855 : }
258 : :
259 : : static void
260 : 1141410 : value_free_string (GValue *value)
261 : : {
262 : 1141410 : if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
263 : 1069338 : g_free (value->data[0].v_pointer);
264 : 1141410 : }
265 : :
266 : : static void
267 : 354 : value_copy_string (const GValue *src_value,
268 : : GValue *dest_value)
269 : : {
270 : 354 : if (src_value->data[1].v_uint & G_VALUE_INTERNED_STRING)
271 : : {
272 : 1 : dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
273 : 1 : dest_value->data[1].v_uint = src_value->data[1].v_uint;
274 : : }
275 : : else
276 : : {
277 : 706 : dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
278 : : /* Don't copy over *any* flags, we're restarting from scratch */
279 : : }
280 : 354 : }
281 : :
282 : : static gchar*
283 : 173357 : value_collect_string (GValue *value,
284 : : guint n_collect_values,
285 : : GTypeCValue *collect_values,
286 : : guint collect_flags)
287 : : {
288 : 173357 : if (!collect_values[0].v_pointer)
289 : 292 : value->data[0].v_pointer = NULL;
290 : 173065 : else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
291 : : {
292 : 72067 : value->data[0].v_pointer = collect_values[0].v_pointer;
293 : 72067 : value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
294 : : }
295 : : else
296 : 201996 : value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
297 : :
298 : 173357 : return NULL;
299 : : }
300 : :
301 : : static gchar*
302 : 966174 : value_lcopy_string (const GValue *value,
303 : : guint n_collect_values,
304 : : GTypeCValue *collect_values,
305 : : guint collect_flags)
306 : : {
307 : 966174 : gchar **string_p = collect_values[0].v_pointer;
308 : :
309 : 966174 : g_return_val_if_fail (string_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
310 : :
311 : 966174 : if (!value->data[0].v_pointer)
312 : 9 : *string_p = NULL;
313 : 966165 : else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
314 : 0 : *string_p = value->data[0].v_pointer;
315 : : else
316 : 1932330 : *string_p = g_strdup (value->data[0].v_pointer);
317 : :
318 : 966174 : return NULL;
319 : : }
320 : :
321 : : static void
322 : 589 : value_init_pointer (GValue *value)
323 : : {
324 : 589 : value->data[0].v_pointer = NULL;
325 : 589 : }
326 : :
327 : : static void
328 : 1 : value_copy_pointer (const GValue *src_value,
329 : : GValue *dest_value)
330 : : {
331 : 1 : dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
332 : 1 : }
333 : :
334 : : static gpointer
335 : 0 : value_peek_pointer0 (const GValue *value)
336 : : {
337 : 0 : return value->data[0].v_pointer;
338 : : }
339 : :
340 : : static gchar*
341 : 128693 : value_collect_pointer (GValue *value,
342 : : guint n_collect_values,
343 : : GTypeCValue *collect_values,
344 : : guint collect_flags)
345 : : {
346 : 128693 : value->data[0].v_pointer = collect_values[0].v_pointer;
347 : :
348 : 128693 : return NULL;
349 : : }
350 : :
351 : : static gchar*
352 : 7 : value_lcopy_pointer (const GValue *value,
353 : : guint n_collect_values,
354 : : GTypeCValue *collect_values,
355 : : guint collect_flags)
356 : : {
357 : 7 : gpointer *pointer_p = collect_values[0].v_pointer;
358 : :
359 : 7 : g_return_val_if_fail (pointer_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
360 : :
361 : 7 : *pointer_p = value->data[0].v_pointer;
362 : :
363 : 7 : return NULL;
364 : : }
365 : :
366 : : static void
367 : 971 : value_free_variant (GValue *value)
368 : : {
369 : 971 : if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) &&
370 : 964 : value->data[0].v_pointer)
371 : 460 : g_variant_unref (value->data[0].v_pointer);
372 : 971 : }
373 : :
374 : : static void
375 : 153 : value_copy_variant (const GValue *src_value,
376 : : GValue *dest_value)
377 : : {
378 : 153 : if (src_value->data[0].v_pointer)
379 : 27 : dest_value->data[0].v_pointer = g_variant_ref_sink (src_value->data[0].v_pointer);
380 : : else
381 : 126 : dest_value->data[0].v_pointer = NULL;
382 : 153 : }
383 : :
384 : : static gchar*
385 : 350 : value_collect_variant (GValue *value,
386 : : guint n_collect_values,
387 : : GTypeCValue *collect_values,
388 : : guint collect_flags)
389 : : {
390 : 350 : if (!collect_values[0].v_pointer)
391 : 15 : value->data[0].v_pointer = NULL;
392 : : else
393 : : /* never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types */
394 : 335 : value->data[0].v_pointer = g_variant_ref_sink (collect_values[0].v_pointer);
395 : :
396 : 350 : return NULL;
397 : : }
398 : :
399 : : static gchar*
400 : 27 : value_lcopy_variant (const GValue *value,
401 : : guint n_collect_values,
402 : : GTypeCValue *collect_values,
403 : : guint collect_flags)
404 : : {
405 : 27 : GVariant **variant_p = collect_values[0].v_pointer;
406 : :
407 : 27 : g_return_val_if_fail (variant_p != NULL, g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value)));
408 : :
409 : 27 : if (!value->data[0].v_pointer)
410 : 1 : *variant_p = NULL;
411 : 26 : else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
412 : 0 : *variant_p = value->data[0].v_pointer;
413 : : else
414 : 26 : *variant_p = g_variant_ref_sink (value->data[0].v_pointer);
415 : :
416 : 27 : return NULL;
417 : : }
418 : :
419 : : /* --- type initialization --- */
420 : : void
421 : 545 : _g_value_types_init (void)
422 : : {
423 : 545 : GTypeInfo info = {
424 : : 0, /* class_size */
425 : : NULL, /* base_init */
426 : : NULL, /* base_destroy */
427 : : NULL, /* class_init */
428 : : NULL, /* class_destroy */
429 : : NULL, /* class_data */
430 : : 0, /* instance_size */
431 : : 0, /* n_preallocs */
432 : : NULL, /* instance_init */
433 : : NULL, /* value_table */
434 : : };
435 : 545 : const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
436 : : GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */;
437 : :
438 : : /* G_TYPE_CHAR / G_TYPE_UCHAR
439 : : */
440 : : {
441 : : static const GTypeValueTable value_table = {
442 : : value_init_long0, /* value_init */
443 : : NULL, /* value_free */
444 : : value_copy_long0, /* value_copy */
445 : : NULL, /* value_peek_pointer */
446 : : "i", /* collect_format */
447 : : value_collect_int, /* collect_value */
448 : : "p", /* lcopy_format */
449 : : value_lcopy_char, /* lcopy_value */
450 : : };
451 : 545 : info.value_table = &value_table;
452 : 545 : type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
453 : 545 : g_assert (type == G_TYPE_CHAR);
454 : 545 : type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
455 : 545 : g_assert (type == G_TYPE_UCHAR);
456 : : }
457 : :
458 : : /* G_TYPE_BOOLEAN
459 : : */
460 : : {
461 : : static const GTypeValueTable value_table = {
462 : : value_init_long0, /* value_init */
463 : : NULL, /* value_free */
464 : : value_copy_long0, /* value_copy */
465 : : NULL, /* value_peek_pointer */
466 : : "i", /* collect_format */
467 : : value_collect_int, /* collect_value */
468 : : "p", /* lcopy_format */
469 : : value_lcopy_boolean, /* lcopy_value */
470 : : };
471 : 545 : info.value_table = &value_table;
472 : 545 : type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
473 : 545 : g_assert (type == G_TYPE_BOOLEAN);
474 : : }
475 : :
476 : : /* G_TYPE_INT / G_TYPE_UINT
477 : : */
478 : : {
479 : : static const GTypeValueTable value_table = {
480 : : value_init_long0, /* value_init */
481 : : NULL, /* value_free */
482 : : value_copy_long0, /* value_copy */
483 : : NULL, /* value_peek_pointer */
484 : : "i", /* collect_format */
485 : : value_collect_int, /* collect_value */
486 : : "p", /* lcopy_format */
487 : : value_lcopy_int, /* lcopy_value */
488 : : };
489 : 545 : info.value_table = &value_table;
490 : 545 : type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
491 : 545 : g_assert (type == G_TYPE_INT);
492 : 545 : type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
493 : 545 : g_assert (type == G_TYPE_UINT);
494 : : }
495 : :
496 : : /* G_TYPE_LONG / G_TYPE_ULONG
497 : : */
498 : : {
499 : : static const GTypeValueTable value_table = {
500 : : value_init_long0, /* value_init */
501 : : NULL, /* value_free */
502 : : value_copy_long0, /* value_copy */
503 : : NULL, /* value_peek_pointer */
504 : : "l", /* collect_format */
505 : : value_collect_long, /* collect_value */
506 : : "p", /* lcopy_format */
507 : : value_lcopy_long, /* lcopy_value */
508 : : };
509 : 545 : info.value_table = &value_table;
510 : 545 : type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
511 : 545 : g_assert (type == G_TYPE_LONG);
512 : 545 : type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
513 : 545 : g_assert (type == G_TYPE_ULONG);
514 : : }
515 : :
516 : : /* G_TYPE_INT64 / G_TYPE_UINT64
517 : : */
518 : : {
519 : : static const GTypeValueTable value_table = {
520 : : value_init_int64, /* value_init */
521 : : NULL, /* value_free */
522 : : value_copy_int64, /* value_copy */
523 : : NULL, /* value_peek_pointer */
524 : : "q", /* collect_format */
525 : : value_collect_int64, /* collect_value */
526 : : "p", /* lcopy_format */
527 : : value_lcopy_int64, /* lcopy_value */
528 : : };
529 : 545 : info.value_table = &value_table;
530 : 545 : type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
531 : 545 : g_assert (type == G_TYPE_INT64);
532 : 545 : type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
533 : 545 : g_assert (type == G_TYPE_UINT64);
534 : : }
535 : :
536 : : /* G_TYPE_FLOAT
537 : : */
538 : : {
539 : : static const GTypeValueTable value_table = {
540 : : value_init_float, /* value_init */
541 : : NULL, /* value_free */
542 : : value_copy_float, /* value_copy */
543 : : NULL, /* value_peek_pointer */
544 : : "d", /* collect_format */
545 : : value_collect_float, /* collect_value */
546 : : "p", /* lcopy_format */
547 : : value_lcopy_float, /* lcopy_value */
548 : : };
549 : 545 : info.value_table = &value_table;
550 : 545 : type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
551 : 545 : g_assert (type == G_TYPE_FLOAT);
552 : : }
553 : :
554 : : /* G_TYPE_DOUBLE
555 : : */
556 : : {
557 : : static const GTypeValueTable value_table = {
558 : : value_init_double, /* value_init */
559 : : NULL, /* value_free */
560 : : value_copy_double, /* value_copy */
561 : : NULL, /* value_peek_pointer */
562 : : "d", /* collect_format */
563 : : value_collect_double, /* collect_value */
564 : : "p", /* lcopy_format */
565 : : value_lcopy_double, /* lcopy_value */
566 : : };
567 : 545 : info.value_table = &value_table;
568 : 545 : type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
569 : 545 : g_assert (type == G_TYPE_DOUBLE);
570 : : }
571 : :
572 : : /* G_TYPE_STRING
573 : : */
574 : : {
575 : : static const GTypeValueTable value_table = {
576 : : value_init_string, /* value_init */
577 : : value_free_string, /* value_free */
578 : : value_copy_string, /* value_copy */
579 : : value_peek_pointer0, /* value_peek_pointer */
580 : : "p", /* collect_format */
581 : : value_collect_string, /* collect_value */
582 : : "p", /* lcopy_format */
583 : : value_lcopy_string, /* lcopy_value */
584 : : };
585 : 545 : info.value_table = &value_table;
586 : 545 : type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
587 : 545 : g_assert (type == G_TYPE_STRING);
588 : : }
589 : :
590 : : /* G_TYPE_POINTER
591 : : */
592 : : {
593 : : static const GTypeValueTable value_table = {
594 : : value_init_pointer, /* value_init */
595 : : NULL, /* value_free */
596 : : value_copy_pointer, /* value_copy */
597 : : value_peek_pointer0, /* value_peek_pointer */
598 : : "p", /* collect_format */
599 : : value_collect_pointer, /* collect_value */
600 : : "p", /* lcopy_format */
601 : : value_lcopy_pointer, /* lcopy_value */
602 : : };
603 : 545 : info.value_table = &value_table;
604 : 545 : type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
605 : 545 : g_assert (type == G_TYPE_POINTER);
606 : : }
607 : :
608 : : /* G_TYPE_VARIANT
609 : : */
610 : : {
611 : : static const GTypeValueTable value_table = {
612 : : value_init_pointer, /* value_init */
613 : : value_free_variant, /* value_free */
614 : : value_copy_variant, /* value_copy */
615 : : value_peek_pointer0, /* value_peek_pointer */
616 : : "p", /* collect_format */
617 : : value_collect_variant, /* collect_value */
618 : : "p", /* lcopy_format */
619 : : value_lcopy_variant, /* lcopy_value */
620 : : };
621 : 545 : info.value_table = &value_table;
622 : 545 : type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0);
623 : 545 : g_assert (type == G_TYPE_VARIANT);
624 : : }
625 : 545 : }
626 : :
627 : :
628 : : /* --- GValue functions --- */
629 : : /**
630 : : * g_value_set_char:
631 : : * @value: a valid #GValue of type %G_TYPE_CHAR
632 : : * @v_char: character value to be set
633 : : *
634 : : * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
635 : : * Deprecated: 2.32: This function's input type is broken, see g_value_set_schar()
636 : : */
637 : : void
638 : 11 : g_value_set_char (GValue *value,
639 : : gchar v_char)
640 : : {
641 : 11 : g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
642 : :
643 : 11 : value->data[0].v_int = v_char;
644 : : }
645 : :
646 : : /**
647 : : * g_value_get_char:
648 : : * @value: a valid #GValue of type %G_TYPE_CHAR
649 : : *
650 : : * Do not use this function; it is broken on platforms where the %char
651 : : * type is unsigned, such as ARM and PowerPC. See g_value_get_schar().
652 : : *
653 : : * Get the contents of a %G_TYPE_CHAR #GValue.
654 : : *
655 : : * Returns: character contents of @value
656 : : * Deprecated: 2.32: This function's return type is broken, see g_value_get_schar()
657 : : */
658 : : gchar
659 : 15 : g_value_get_char (const GValue *value)
660 : : {
661 : 15 : g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
662 : :
663 : 15 : return value->data[0].v_int;
664 : : }
665 : :
666 : : /**
667 : : * g_value_set_schar:
668 : : * @value: a valid #GValue of type %G_TYPE_CHAR
669 : : * @v_char: signed 8 bit integer to be set
670 : : *
671 : : * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
672 : : *
673 : : * Since: 2.32
674 : : */
675 : : void
676 : 10 : g_value_set_schar (GValue *value,
677 : : gint8 v_char)
678 : : {
679 : 10 : g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
680 : :
681 : 10 : value->data[0].v_int = v_char;
682 : : }
683 : :
684 : : /**
685 : : * g_value_get_schar:
686 : : * @value: a valid #GValue of type %G_TYPE_CHAR
687 : : *
688 : : * Get the contents of a %G_TYPE_CHAR #GValue.
689 : : *
690 : : * Returns: signed 8 bit integer contents of @value
691 : : * Since: 2.32
692 : : */
693 : : gint8
694 : 41 : g_value_get_schar (const GValue *value)
695 : : {
696 : 41 : g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
697 : :
698 : 41 : return value->data[0].v_int;
699 : : }
700 : :
701 : : /**
702 : : * g_value_set_uchar:
703 : : * @value: a valid #GValue of type %G_TYPE_UCHAR
704 : : * @v_uchar: unsigned character value to be set
705 : : *
706 : : * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
707 : : */
708 : : void
709 : 10 : g_value_set_uchar (GValue *value,
710 : : guchar v_uchar)
711 : : {
712 : 10 : g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
713 : :
714 : 10 : value->data[0].v_uint = v_uchar;
715 : : }
716 : :
717 : : /**
718 : : * g_value_get_uchar:
719 : : * @value: a valid #GValue of type %G_TYPE_UCHAR
720 : : *
721 : : * Get the contents of a %G_TYPE_UCHAR #GValue.
722 : : *
723 : : * Returns: unsigned character contents of @value
724 : : */
725 : : guchar
726 : 114 : g_value_get_uchar (const GValue *value)
727 : : {
728 : 114 : g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
729 : :
730 : 114 : return value->data[0].v_uint;
731 : : }
732 : :
733 : : /**
734 : : * g_value_set_boolean:
735 : : * @value: a valid #GValue of type %G_TYPE_BOOLEAN
736 : : * @v_boolean: boolean value to be set
737 : : *
738 : : * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
739 : : */
740 : : void
741 : 13402 : g_value_set_boolean (GValue *value,
742 : : gboolean v_boolean)
743 : : {
744 : 13402 : g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
745 : :
746 : 13402 : value->data[0].v_int = v_boolean != FALSE;
747 : : }
748 : :
749 : : /**
750 : : * g_value_get_boolean:
751 : : * @value: a valid #GValue of type %G_TYPE_BOOLEAN
752 : : *
753 : : * Get the contents of a %G_TYPE_BOOLEAN #GValue.
754 : : *
755 : : * Returns: boolean contents of @value
756 : : */
757 : : gboolean
758 : 123592 : g_value_get_boolean (const GValue *value)
759 : : {
760 : 123592 : g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
761 : :
762 : 123592 : return value->data[0].v_int;
763 : : }
764 : :
765 : : /**
766 : : * g_value_set_int:
767 : : * @value: a valid #GValue of type %G_TYPE_INT
768 : : * @v_int: integer value to be set
769 : : *
770 : : * Set the contents of a %G_TYPE_INT #GValue to @v_int.
771 : : */
772 : : void
773 : 11225185 : g_value_set_int (GValue *value,
774 : : gint v_int)
775 : : {
776 : 11225185 : g_return_if_fail (G_VALUE_HOLDS_INT (value));
777 : :
778 : 11225185 : value->data[0].v_int = v_int;
779 : : }
780 : :
781 : : /**
782 : : * g_value_get_int:
783 : : * @value: a valid #GValue of type %G_TYPE_INT
784 : : *
785 : : * Get the contents of a %G_TYPE_INT #GValue.
786 : : *
787 : : * Returns: integer contents of @value
788 : : */
789 : : gint
790 : 15144764 : g_value_get_int (const GValue *value)
791 : : {
792 : 15144764 : g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
793 : :
794 : 15144764 : return value->data[0].v_int;
795 : : }
796 : :
797 : : /**
798 : : * g_value_set_uint:
799 : : * @value: a valid #GValue of type %G_TYPE_UINT
800 : : * @v_uint: unsigned integer value to be set
801 : : *
802 : : * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
803 : : */
804 : : void
805 : 998 : g_value_set_uint (GValue *value,
806 : : guint v_uint)
807 : : {
808 : 998 : g_return_if_fail (G_VALUE_HOLDS_UINT (value));
809 : :
810 : 998 : value->data[0].v_uint = v_uint;
811 : : }
812 : :
813 : : /**
814 : : * g_value_get_uint:
815 : : * @value: a valid #GValue of type %G_TYPE_UINT
816 : : *
817 : : * Get the contents of a %G_TYPE_UINT #GValue.
818 : : *
819 : : * Returns: unsigned integer contents of @value
820 : : */
821 : : guint
822 : 192340 : g_value_get_uint (const GValue *value)
823 : : {
824 : 192340 : g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
825 : :
826 : 192340 : return value->data[0].v_uint;
827 : : }
828 : :
829 : : /**
830 : : * g_value_set_long:
831 : : * @value: a valid #GValue of type %G_TYPE_LONG
832 : : * @v_long: long integer value to be set
833 : : *
834 : : * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
835 : : */
836 : : void
837 : 20 : g_value_set_long (GValue *value,
838 : : glong v_long)
839 : : {
840 : 20 : g_return_if_fail (G_VALUE_HOLDS_LONG (value));
841 : :
842 : 20 : value->data[0].v_long = v_long;
843 : : }
844 : :
845 : : /**
846 : : * g_value_get_long:
847 : : * @value: a valid #GValue of type %G_TYPE_LONG
848 : : *
849 : : * Get the contents of a %G_TYPE_LONG #GValue.
850 : : *
851 : : * Returns: long integer contents of @value
852 : : */
853 : : glong
854 : 31 : g_value_get_long (const GValue *value)
855 : : {
856 : 31 : g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
857 : :
858 : 31 : return value->data[0].v_long;
859 : : }
860 : :
861 : : /**
862 : : * g_value_set_ulong:
863 : : * @value: a valid #GValue of type %G_TYPE_ULONG
864 : : * @v_ulong: unsigned long integer value to be set
865 : : *
866 : : * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
867 : : */
868 : : void
869 : 25 : g_value_set_ulong (GValue *value,
870 : : gulong v_ulong)
871 : : {
872 : 25 : g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
873 : :
874 : 25 : value->data[0].v_ulong = v_ulong;
875 : : }
876 : :
877 : : /**
878 : : * g_value_get_ulong:
879 : : * @value: a valid #GValue of type %G_TYPE_ULONG
880 : : *
881 : : * Get the contents of a %G_TYPE_ULONG #GValue.
882 : : *
883 : : * Returns: unsigned long integer contents of @value
884 : : */
885 : : gulong
886 : 1192 : g_value_get_ulong (const GValue *value)
887 : : {
888 : 1192 : g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
889 : :
890 : 1192 : return value->data[0].v_ulong;
891 : : }
892 : :
893 : : /**
894 : : * g_value_get_int64:
895 : : * @value: a valid #GValue of type %G_TYPE_INT64
896 : : *
897 : : * Get the contents of a %G_TYPE_INT64 #GValue.
898 : : *
899 : : * Returns: 64bit integer contents of @value
900 : : */
901 : : void
902 : 34 : g_value_set_int64 (GValue *value,
903 : : gint64 v_int64)
904 : : {
905 : 34 : g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
906 : :
907 : 34 : value->data[0].v_int64 = v_int64;
908 : : }
909 : :
910 : : /**
911 : : * g_value_set_int64:
912 : : * @value: a valid #GValue of type %G_TYPE_INT64
913 : : * @v_int64: 64bit integer value to be set
914 : : *
915 : : * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
916 : : */
917 : : gint64
918 : 59 : g_value_get_int64 (const GValue *value)
919 : : {
920 : 59 : g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
921 : :
922 : 59 : return value->data[0].v_int64;
923 : : }
924 : :
925 : : /**
926 : : * g_value_set_uint64:
927 : : * @value: a valid #GValue of type %G_TYPE_UINT64
928 : : * @v_uint64: unsigned 64bit integer value to be set
929 : : *
930 : : * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
931 : : */
932 : : void
933 : 35 : g_value_set_uint64 (GValue *value,
934 : : guint64 v_uint64)
935 : : {
936 : 35 : g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
937 : :
938 : 35 : value->data[0].v_uint64 = v_uint64;
939 : : }
940 : :
941 : : /**
942 : : * g_value_get_uint64:
943 : : * @value: a valid #GValue of type %G_TYPE_UINT64
944 : : *
945 : : * Get the contents of a %G_TYPE_UINT64 #GValue.
946 : : *
947 : : * Returns: unsigned 64bit integer contents of @value
948 : : */
949 : : guint64
950 : 64 : g_value_get_uint64 (const GValue *value)
951 : : {
952 : 64 : g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
953 : :
954 : 64 : return value->data[0].v_uint64;
955 : : }
956 : :
957 : : /**
958 : : * g_value_set_float:
959 : : * @value: a valid #GValue of type %G_TYPE_FLOAT
960 : : * @v_float: float value to be set
961 : : *
962 : : * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
963 : : */
964 : : void
965 : 18 : g_value_set_float (GValue *value,
966 : : gfloat v_float)
967 : : {
968 : 18 : g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
969 : :
970 : 18 : value->data[0].v_float = v_float;
971 : : }
972 : :
973 : : /**
974 : : * g_value_get_float:
975 : : * @value: a valid #GValue of type %G_TYPE_FLOAT
976 : : *
977 : : * Get the contents of a %G_TYPE_FLOAT #GValue.
978 : : *
979 : : * Returns: float contents of @value
980 : : */
981 : : gfloat
982 : 30 : g_value_get_float (const GValue *value)
983 : : {
984 : 30 : g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
985 : :
986 : 30 : return value->data[0].v_float;
987 : : }
988 : :
989 : : /**
990 : : * g_value_set_double:
991 : : * @value: a valid #GValue of type %G_TYPE_DOUBLE
992 : : * @v_double: double value to be set
993 : : *
994 : : * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
995 : : */
996 : : void
997 : 96 : g_value_set_double (GValue *value,
998 : : gdouble v_double)
999 : : {
1000 : 96 : g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
1001 : :
1002 : 96 : value->data[0].v_double = v_double;
1003 : : }
1004 : :
1005 : : /**
1006 : : * g_value_get_double:
1007 : : * @value: a valid #GValue of type %G_TYPE_DOUBLE
1008 : : *
1009 : : * Get the contents of a %G_TYPE_DOUBLE #GValue.
1010 : : *
1011 : : * Returns: double contents of @value
1012 : : */
1013 : : gdouble
1014 : 194 : g_value_get_double (const GValue *value)
1015 : : {
1016 : 194 : g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
1017 : :
1018 : 194 : return value->data[0].v_double;
1019 : : }
1020 : :
1021 : : /**
1022 : : * g_value_set_string:
1023 : : * @value: a valid #GValue of type %G_TYPE_STRING
1024 : : * @v_string: (nullable): caller-owned string to be duplicated for the #GValue
1025 : : *
1026 : : * Set the contents of a %G_TYPE_STRING #GValue to a copy of @v_string.
1027 : : */
1028 : : void
1029 : 722 : g_value_set_string (GValue *value,
1030 : : const gchar *v_string)
1031 : : {
1032 : : gchar *new_val;
1033 : :
1034 : 722 : g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1035 : :
1036 : 722 : new_val = g_strdup (v_string);
1037 : :
1038 : 722 : if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1039 : 1 : value->data[1].v_uint = 0;
1040 : : else
1041 : 721 : g_free (value->data[0].v_pointer);
1042 : :
1043 : 722 : value->data[0].v_pointer = new_val;
1044 : : }
1045 : :
1046 : : /**
1047 : : * g_value_set_static_string:
1048 : : * @value: a valid #GValue of type %G_TYPE_STRING
1049 : : * @v_string: (nullable): static string to be set
1050 : : *
1051 : : * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1052 : : * The string is assumed to be static, and is thus not duplicated
1053 : : * when setting the #GValue.
1054 : : *
1055 : : * If the the string is a canonical string, using g_value_set_interned_string()
1056 : : * is more appropriate.
1057 : : */
1058 : : void
1059 : 7 : g_value_set_static_string (GValue *value,
1060 : : const gchar *v_string)
1061 : : {
1062 : 7 : g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1063 : :
1064 : 7 : if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
1065 : 6 : g_free (value->data[0].v_pointer);
1066 : 7 : value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
1067 : 7 : value->data[0].v_pointer = (gchar*) v_string;
1068 : : }
1069 : :
1070 : : /**
1071 : : * g_value_set_interned_string:
1072 : : * @value: a valid #GValue of type %G_TYPE_STRING
1073 : : * @v_string: (nullable): static string to be set
1074 : : *
1075 : : * Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is
1076 : : * assumed to be static and interned (canonical, for example from
1077 : : * g_intern_string()), and is thus not duplicated when setting the #GValue.
1078 : : *
1079 : : * Since: 2.66
1080 : : */
1081 : : void
1082 : 4 : g_value_set_interned_string (GValue *value,
1083 : : const gchar *v_string)
1084 : : {
1085 : 4 : g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1086 : :
1087 : 4 : if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
1088 : 3 : g_free (value->data[0].v_pointer);
1089 : 4 : value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS | G_VALUE_INTERNED_STRING;
1090 : 4 : value->data[0].v_pointer = (gchar *) v_string;
1091 : : }
1092 : :
1093 : : /**
1094 : : * g_value_set_string_take_ownership:
1095 : : * @value: a valid #GValue of type %G_TYPE_STRING
1096 : : * @v_string: (nullable): duplicated unowned string to be set
1097 : : *
1098 : : * This is an internal function introduced mainly for C marshallers.
1099 : : *
1100 : : * Deprecated: 2.4: Use g_value_take_string() instead.
1101 : : */
1102 : : void
1103 : 0 : g_value_set_string_take_ownership (GValue *value,
1104 : : gchar *v_string)
1105 : : {
1106 : 0 : g_value_take_string (value, v_string);
1107 : 0 : }
1108 : :
1109 : : /**
1110 : : * g_value_take_string:
1111 : : * @value: a valid #GValue of type %G_TYPE_STRING
1112 : : * @v_string: (nullable) (transfer full): string to take ownership of
1113 : : *
1114 : : * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1115 : : *
1116 : : * Since: 2.4
1117 : : */
1118 : : void
1119 : 965644 : g_value_take_string (GValue *value,
1120 : : gchar *v_string)
1121 : : {
1122 : 965644 : g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1123 : :
1124 : 965644 : if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1125 : 1 : value->data[1].v_uint = 0;
1126 : : else
1127 : 965643 : g_free (value->data[0].v_pointer);
1128 : 965644 : value->data[0].v_pointer = v_string;
1129 : : }
1130 : :
1131 : : /**
1132 : : * g_value_get_string:
1133 : : * @value: a valid #GValue of type %G_TYPE_STRING
1134 : : *
1135 : : * Get the contents of a %G_TYPE_STRING #GValue.
1136 : : *
1137 : : * Returns: (nullable) (transfer none): string content of @value
1138 : : */
1139 : : const gchar*
1140 : 104787 : g_value_get_string (const GValue *value)
1141 : : {
1142 : 104787 : g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1143 : :
1144 : 104787 : return value->data[0].v_pointer;
1145 : : }
1146 : :
1147 : : /**
1148 : : * g_value_dup_string:
1149 : : * @value: a valid #GValue of type %G_TYPE_STRING
1150 : : *
1151 : : * Get a copy the contents of a %G_TYPE_STRING #GValue.
1152 : : *
1153 : : * Returns: (nullable) (transfer full): a newly allocated copy of the string content of @value
1154 : : */
1155 : : gchar*
1156 : 72369 : g_value_dup_string (const GValue *value)
1157 : : {
1158 : 72369 : g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1159 : :
1160 : 144738 : return g_strdup (value->data[0].v_pointer);
1161 : : }
1162 : :
1163 : : /**
1164 : : * g_value_steal_string:
1165 : : * @value: a valid #GValue of type %G_TYPE_STRING
1166 : : *
1167 : : * Steal ownership on contents of a %G_TYPE_STRING #GValue.
1168 : : * As a result of this operation the value's contents will be reset to %NULL.
1169 : : *
1170 : : * The purpose of this call is to provide a way to avoid an extra copy
1171 : : * when some object have been serialized into string through #GValue API.
1172 : : *
1173 : : * NOTE: for safety and compatibility purposes, if #GValue contains
1174 : : * static string, or an interned one, this function will return a copy
1175 : : * of the string. Otherwise the transfer notation would be ambiguous.
1176 : : *
1177 : : * Returns: (nullable) (transfer full): string content of @value;
1178 : : * Should be freed with g_free() when no longer needed.
1179 : : *
1180 : : * Since: 2.80
1181 : : */
1182 : : gchar*
1183 : 3 : g_value_steal_string (GValue *value)
1184 : : {
1185 : : gchar *ret;
1186 : :
1187 : 3 : g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1188 : :
1189 : 3 : ret = value->data[0].v_pointer;
1190 : 3 : value->data[0].v_pointer = NULL;
1191 : :
1192 : 3 : if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1193 : 1 : return g_strdup (ret);
1194 : :
1195 : 2 : return ret;
1196 : : }
1197 : :
1198 : : /**
1199 : : * g_value_set_pointer:
1200 : : * @value: a valid #GValue of %G_TYPE_POINTER
1201 : : * @v_pointer: pointer value to be set
1202 : : *
1203 : : * Set the contents of a pointer #GValue to @v_pointer.
1204 : : */
1205 : : void
1206 : 8 : g_value_set_pointer (GValue *value,
1207 : : gpointer v_pointer)
1208 : : {
1209 : 8 : g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1210 : :
1211 : 8 : value->data[0].v_pointer = v_pointer;
1212 : : }
1213 : :
1214 : : /**
1215 : : * g_value_get_pointer:
1216 : : * @value: a valid #GValue of %G_TYPE_POINTER
1217 : : *
1218 : : * Get the contents of a pointer #GValue.
1219 : : *
1220 : : * Returns: (transfer none): pointer contents of @value
1221 : : */
1222 : : gpointer
1223 : 189904 : g_value_get_pointer (const GValue *value)
1224 : : {
1225 : 189904 : g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1226 : :
1227 : 189904 : return value->data[0].v_pointer;
1228 : : }
1229 : :
1230 : 1177 : G_DEFINE_POINTER_TYPE (GType, g_gtype)
1231 : :
1232 : : /**
1233 : : * g_value_set_gtype:
1234 : : * @value: a valid #GValue of type %G_TYPE_GTYPE
1235 : : * @v_gtype: #GType to be set
1236 : : *
1237 : : * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1238 : : *
1239 : : * Since: 2.12
1240 : : */
1241 : : void
1242 : 9 : g_value_set_gtype (GValue *value,
1243 : : GType v_gtype)
1244 : : {
1245 : 9 : g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1246 : :
1247 : 9 : value->data[0].v_pointer = GTYPE_TO_POINTER (v_gtype);
1248 : :
1249 : : }
1250 : :
1251 : : /**
1252 : : * g_value_get_gtype:
1253 : : * @value: a valid #GValue of type %G_TYPE_GTYPE
1254 : : *
1255 : : * Get the contents of a %G_TYPE_GTYPE #GValue.
1256 : : *
1257 : : * Since: 2.12
1258 : : *
1259 : : * Returns: the #GType stored in @value
1260 : : */
1261 : : GType
1262 : 71 : g_value_get_gtype (const GValue *value)
1263 : : {
1264 : 71 : g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1265 : :
1266 : 71 : return GPOINTER_TO_TYPE (value->data[0].v_pointer);
1267 : : }
1268 : :
1269 : : /**
1270 : : * g_value_set_variant:
1271 : : * @value: a valid #GValue of type %G_TYPE_VARIANT
1272 : : * @variant: (nullable): a #GVariant, or %NULL
1273 : : *
1274 : : * Set the contents of a variant #GValue to @variant.
1275 : : * If the variant is floating, it is consumed.
1276 : : *
1277 : : * Since: 2.26
1278 : : */
1279 : : void
1280 : 107 : g_value_set_variant (GValue *value,
1281 : : GVariant *variant)
1282 : : {
1283 : : GVariant *old_variant;
1284 : :
1285 : 107 : g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1286 : :
1287 : 107 : old_variant = value->data[0].v_pointer;
1288 : :
1289 : 107 : if (variant)
1290 : 102 : value->data[0].v_pointer = g_variant_ref_sink (variant);
1291 : : else
1292 : 5 : value->data[0].v_pointer = NULL;
1293 : :
1294 : 107 : if (old_variant)
1295 : 0 : g_variant_unref (old_variant);
1296 : : }
1297 : :
1298 : : /**
1299 : : * g_value_take_variant:
1300 : : * @value: a valid #GValue of type %G_TYPE_VARIANT
1301 : : * @variant: (nullable) (transfer full): a #GVariant, or %NULL
1302 : : *
1303 : : * Set the contents of a variant #GValue to @variant, and takes over
1304 : : * the ownership of the caller's reference to @variant;
1305 : : * the caller doesn't have to unref it any more (i.e. the reference
1306 : : * count of the variant is not increased).
1307 : : *
1308 : : * If @variant was floating then its floating reference is converted to
1309 : : * a hard reference.
1310 : : *
1311 : : * If you want the #GValue to hold its own reference to @variant, use
1312 : : * g_value_set_variant() instead.
1313 : : *
1314 : : * This is an internal function introduced mainly for C marshallers.
1315 : : *
1316 : : * Since: 2.26
1317 : : */
1318 : : void
1319 : 13 : g_value_take_variant (GValue *value,
1320 : : GVariant *variant)
1321 : : {
1322 : : GVariant *old_variant;
1323 : :
1324 : 13 : g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1325 : :
1326 : 13 : old_variant = value->data[0].v_pointer;
1327 : :
1328 : 13 : if (variant)
1329 : 11 : value->data[0].v_pointer = g_variant_take_ref (variant);
1330 : : else
1331 : 2 : value->data[0].v_pointer = NULL;
1332 : :
1333 : 13 : if (old_variant)
1334 : 0 : g_variant_unref (old_variant);
1335 : : }
1336 : :
1337 : : /**
1338 : : * g_value_get_variant:
1339 : : * @value: a valid #GValue of type %G_TYPE_VARIANT
1340 : : *
1341 : : * Get the contents of a variant #GValue.
1342 : : *
1343 : : * Returns: (transfer none) (nullable): variant contents of @value (may be %NULL)
1344 : : *
1345 : : * Since: 2.26
1346 : : */
1347 : : GVariant*
1348 : 384 : g_value_get_variant (const GValue *value)
1349 : : {
1350 : 384 : g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1351 : :
1352 : 384 : return value->data[0].v_pointer;
1353 : : }
1354 : :
1355 : : /**
1356 : : * g_value_dup_variant:
1357 : : * @value: a valid #GValue of type %G_TYPE_VARIANT
1358 : : *
1359 : : * Get the contents of a variant #GValue, increasing its refcount. The returned
1360 : : * #GVariant is never floating.
1361 : : *
1362 : : * Returns: (transfer full) (nullable): variant contents of @value (may be %NULL);
1363 : : * should be unreffed using g_variant_unref() when no longer needed
1364 : : *
1365 : : * Since: 2.26
1366 : : */
1367 : : GVariant*
1368 : 338 : g_value_dup_variant (const GValue *value)
1369 : : {
1370 : : GVariant *variant;
1371 : :
1372 : 338 : g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1373 : :
1374 : 338 : variant = value->data[0].v_pointer;
1375 : 338 : if (variant)
1376 : 80 : g_variant_ref_sink (variant);
1377 : :
1378 : 338 : return variant;
1379 : : }
1380 : :
1381 : : /**
1382 : : * g_strdup_value_contents:
1383 : : * @value: #GValue which contents are to be described.
1384 : : *
1385 : : * Return a newly allocated string, which describes the contents of a
1386 : : * #GValue. The main purpose of this function is to describe #GValue
1387 : : * contents for debugging output, the way in which the contents are
1388 : : * described may change between different GLib versions.
1389 : : *
1390 : : * Returns: Newly allocated string.
1391 : : */
1392 : : gchar*
1393 : 0 : g_strdup_value_contents (const GValue *value)
1394 : : {
1395 : : const gchar *src;
1396 : : gchar *contents;
1397 : :
1398 : 0 : g_return_val_if_fail (G_IS_VALUE (value), NULL);
1399 : :
1400 : 0 : if (G_VALUE_HOLDS_STRING (value))
1401 : : {
1402 : 0 : src = g_value_get_string (value);
1403 : :
1404 : 0 : if (!src)
1405 : 0 : contents = g_strdup ("NULL");
1406 : : else
1407 : : {
1408 : 0 : gchar *s = g_strescape (src, NULL);
1409 : :
1410 : 0 : contents = g_strdup_printf ("\"%s\"", s);
1411 : 0 : g_free (s);
1412 : : }
1413 : : }
1414 : 0 : else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1415 : : {
1416 : 0 : GValue tmp_value = G_VALUE_INIT;
1417 : : gchar *s;
1418 : :
1419 : 0 : g_value_init (&tmp_value, G_TYPE_STRING);
1420 : 0 : g_value_transform (value, &tmp_value);
1421 : 0 : s = g_strescape (g_value_get_string (&tmp_value), NULL);
1422 : 0 : g_value_unset (&tmp_value);
1423 : 0 : if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
1424 : 0 : contents = g_strdup_printf ("((%s) %s)",
1425 : : g_type_name (G_VALUE_TYPE (value)),
1426 : : s);
1427 : : else
1428 : 0 : contents = g_strdup (s ? s : "NULL");
1429 : 0 : g_free (s);
1430 : : }
1431 : 0 : else if (g_value_fits_pointer (value))
1432 : : {
1433 : 0 : gpointer p = g_value_peek_pointer (value);
1434 : :
1435 : 0 : if (!p)
1436 : 0 : contents = g_strdup ("NULL");
1437 : 0 : else if (G_VALUE_HOLDS_OBJECT (value))
1438 : 0 : contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
1439 : 0 : else if (G_VALUE_HOLDS_PARAM (value))
1440 : 0 : contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
1441 : 0 : else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
1442 : : {
1443 : 0 : GStrv strv = g_value_get_boxed (value);
1444 : 0 : GString *tmp = g_string_new ("[");
1445 : :
1446 : 0 : while (*strv != NULL)
1447 : : {
1448 : 0 : gchar *escaped = g_strescape (*strv, NULL);
1449 : :
1450 : 0 : g_string_append_printf (tmp, "\"%s\"", escaped);
1451 : 0 : g_free (escaped);
1452 : :
1453 : 0 : if (*++strv != NULL)
1454 : 0 : g_string_append (tmp, ", ");
1455 : : }
1456 : :
1457 : 0 : g_string_append (tmp, "]");
1458 : 0 : contents = g_string_free (tmp, FALSE);
1459 : : }
1460 : 0 : else if (G_VALUE_HOLDS_BOXED (value))
1461 : 0 : contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
1462 : 0 : else if (G_VALUE_HOLDS_POINTER (value))
1463 : 0 : contents = g_strdup_printf ("((gpointer) %p)", p);
1464 : : else
1465 : 0 : contents = g_strdup ("???");
1466 : : }
1467 : : else
1468 : 0 : contents = g_strdup ("???");
1469 : :
1470 : 0 : return contents;
1471 : : }
1472 : :
1473 : : /**
1474 : : * g_pointer_type_register_static:
1475 : : * @name: the name of the new pointer type.
1476 : : *
1477 : : * Creates a new %G_TYPE_POINTER derived type id for a new
1478 : : * pointer type with name @name.
1479 : : *
1480 : : * Returns: a new %G_TYPE_POINTER derived type id for @name.
1481 : : */
1482 : : GType
1483 : 546 : g_pointer_type_register_static (const gchar *name)
1484 : : {
1485 : 546 : const GTypeInfo type_info = {
1486 : : 0, /* class_size */
1487 : : NULL, /* base_init */
1488 : : NULL, /* base_finalize */
1489 : : NULL, /* class_init */
1490 : : NULL, /* class_finalize */
1491 : : NULL, /* class_data */
1492 : : 0, /* instance_size */
1493 : : 0, /* n_preallocs */
1494 : : NULL, /* instance_init */
1495 : : NULL /* value_table */
1496 : : };
1497 : : GType type;
1498 : :
1499 : 546 : g_return_val_if_fail (name != NULL, 0);
1500 : 546 : g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1501 : :
1502 : 546 : type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
1503 : :
1504 : 546 : return type;
1505 : : }
|
