gobject/gvaluetypes.c

   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  * 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.
   9  *
  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.
  14  *
  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.
  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 value_init_long0 (GValue *value)
  42 {
  43   value->data[0].v_long = 0;
  44 }
  45
  46 static void
  47 value_copy_long0 (const GValue *src_value,
  48                   GValue       *dest_value)
  49 {
  50   dest_value->data[0].v_long = src_value->data[0].v_long;
  51 }
  52
  53 static gchar*
  54 value_lcopy_char (const GValue *value,
  55                   guint         n_collect_values,
  56                   GTypeCValue  *collect_values,
  57                   guint         collect_flags)
  58 {
  59   gint8 *int8_p = collect_values[0].v_pointer;
  60
  61   if (!int8_p)
  62     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  63
  64   *int8_p = value->data[0].v_int;
  65
  66   return NULL;
  67 }
  68
  69 static gchar*
  70 value_lcopy_boolean (const GValue *value,
  71                      guint         n_collect_values,
  72                      GTypeCValue  *collect_values,
  73                      guint         collect_flags)
  74 {
  75   gboolean *bool_p = collect_values[0].v_pointer;
  76
  77   if (!bool_p)
  78     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  79
  80   *bool_p = value->data[0].v_int;
  81
  82   return NULL;
  83 }
  84
  85 static gchar*
  86 value_collect_int (GValue      *value,
  87                    guint        n_collect_values,
  88                    GTypeCValue *collect_values,
  89                    guint        collect_flags)
  90 {
  91   value->data[0].v_int = collect_values[0].v_int;
  92
  93   return NULL;
  94 }
  95
  96 static gchar*
  97 value_lcopy_int (const GValue *value,
  98                  guint         n_collect_values,
  99                  GTypeCValue  *collect_values,
 100                  guint         collect_flags)
 101 {
 102   gint *int_p = collect_values[0].v_pointer;
 103
 104   if (!int_p)
 105     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 106
 107   *int_p = value->data[0].v_int;
 108
 109   return NULL;
 110 }
 111
 112 static gchar*
 113 value_collect_long (GValue      *value,
 114                     guint        n_collect_values,
 115                     GTypeCValue *collect_values,
 116                     guint        collect_flags)
 117 {
 118   value->data[0].v_long = collect_values[0].v_long;
 119
 120   return NULL;
 121 }
 122
 123 static gchar*
 124 value_lcopy_long (const GValue *value,
 125                   guint         n_collect_values,
 126                   GTypeCValue  *collect_values,
 127                   guint         collect_flags)
 128 {
 129   glong *long_p = collect_values[0].v_pointer;
 130
 131   if (!long_p)
 132     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 133
 134   *long_p = value->data[0].v_long;
 135
 136   return NULL;
 137 }
 138
 139 static void
 140 value_init_int64 (GValue *value)
 141 {
 142   value->data[0].v_int64 = 0;
 143 }
 144
 145 static void
 146 value_copy_int64 (const GValue *src_value,
 147                   GValue       *dest_value)
 148 {
 149   dest_value->data[0].v_int64 = src_value->data[0].v_int64;
 150 }
 151
 152 static gchar*
 153 value_collect_int64 (GValue      *value,
 154                      guint        n_collect_values,
 155                      GTypeCValue *collect_values,
 156                      guint        collect_flags)
 157 {
 158   value->data[0].v_int64 = collect_values[0].v_int64;
 159
 160   return NULL;
 161 }
 162
 163 static gchar*
 164 value_lcopy_int64 (const GValue *value,
 165                    guint         n_collect_values,
 166                    GTypeCValue  *collect_values,
 167                    guint         collect_flags)
 168 {
 169   gint64 *int64_p = collect_values[0].v_pointer;
 170
 171   if (!int64_p)
 172     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 173
 174   *int64_p = value->data[0].v_int64;
 175
 176   return NULL;
 177 }
 178
 179 static void
 180 value_init_float (GValue *value)
 181 {
 182   value->data[0].v_float = 0.0;
 183 }
 184
 185 static void
 186 value_copy_float (const GValue *src_value,
 187                   GValue       *dest_value)
 188 {
 189   dest_value->data[0].v_float = src_value->data[0].v_float;
 190 }
 191
 192 static gchar*
 193 value_collect_float (GValue      *value,
 194                      guint        n_collect_values,
 195                      GTypeCValue *collect_values,
 196                      guint        collect_flags)
 197 {
 198   value->data[0].v_float = collect_values[0].v_double;
 199
 200   return NULL;
 201 }
 202
 203 static gchar*
 204 value_lcopy_float (const GValue *value,
 205                    guint         n_collect_values,
 206                    GTypeCValue  *collect_values,
 207                    guint         collect_flags)
 208 {
 209   gfloat *float_p = collect_values[0].v_pointer;
 210
 211   if (!float_p)
 212     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 213
 214   *float_p = value->data[0].v_float;
 215
 216   return NULL;
 217 }
 218
 219 static void
 220 value_init_double (GValue *value)
 221 {
 222   value->data[0].v_double = 0.0;
 223 }
 224
 225 static void
 226 value_copy_double (const GValue *src_value,
 227                    GValue       *dest_value)
 228 {
 229   dest_value->data[0].v_double = src_value->data[0].v_double;
 230 }
 231
 232 static gchar*
 233 value_collect_double (GValue      *value,
 234                       guint        n_collect_values,
 235                       GTypeCValue *collect_values,
 236                       guint        collect_flags)
 237 {
 238   value->data[0].v_double = collect_values[0].v_double;
 239
 240   return NULL;
 241 }
 242
 243 static gchar*
 244 value_lcopy_double (const GValue *value,
 245                     guint         n_collect_values,
 246                     GTypeCValue  *collect_values,
 247                     guint         collect_flags)
 248 {
 249   gdouble *double_p = collect_values[0].v_pointer;
 250
 251   if (!double_p)
 252     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 253
 254   *double_p = value->data[0].v_double;
 255
 256   return NULL;
 257 }
 258
 259 static void
 260 value_init_string (GValue *value)
 261 {
 262   value->data[0].v_pointer = NULL;
 263 }
 264
 265 static void
 266 value_free_string (GValue *value)
 267 {
 268   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 269     g_free (value->data[0].v_pointer);
 270 }
 271
 272 static void
 273 value_copy_string (const GValue *src_value,
 274                    GValue       *dest_value)
 275 {
 276   dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
 277 }
 278
 279 static gchar*
 280 value_collect_string (GValue      *value,
 281                       guint        n_collect_values,
 282                       GTypeCValue *collect_values,
 283                       guint        collect_flags)
 284 {
 285   if (!collect_values[0].v_pointer)
 286     value->data[0].v_pointer = NULL;
 287   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 288     {
 289       value->data[0].v_pointer = collect_values[0].v_pointer;
 290       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 291     }
 292   else
 293     value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
 294
 295   return NULL;
 296 }
 297
 298 static gchar*
 299 value_lcopy_string (const GValue *value,
 300                     guint         n_collect_values,
 301                     GTypeCValue  *collect_values,
 302                     guint         collect_flags)
 303 {
 304   gchar **string_p = collect_values[0].v_pointer;
 305
 306   if (!string_p)
 307     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 308
 309   if (!value->data[0].v_pointer)
 310     *string_p = NULL;
 311   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 312     *string_p = value->data[0].v_pointer;
 313   else
 314     *string_p = g_strdup (value->data[0].v_pointer);
 315
 316   return NULL;
 317 }
 318
 319 static void
 320 value_init_pointer (GValue *value)
 321 {
 322   value->data[0].v_pointer = NULL;
 323 }
 324
 325 static void
 326 value_copy_pointer (const GValue *src_value,
 327                     GValue       *dest_value)
 328 {
 329   dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
 330 }
 331
 332 static gpointer
 333 value_peek_pointer0 (const GValue *value)
 334 {
 335   return value->data[0].v_pointer;
 336 }
 337
 338 static gchar*
 339 value_collect_pointer (GValue      *value,
 340                        guint        n_collect_values,
 341                        GTypeCValue *collect_values,
 342                        guint        collect_flags)
 343 {
 344   value->data[0].v_pointer = collect_values[0].v_pointer;
 345
 346   return NULL;
 347 }
 348
 349 static gchar*
 350 value_lcopy_pointer (const GValue *value,
 351                      guint         n_collect_values,
 352                      GTypeCValue  *collect_values,
 353                      guint         collect_flags)
 354 {
 355   gpointer *pointer_p = collect_values[0].v_pointer;
 356
 357   if (!pointer_p)
 358     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 359
 360   *pointer_p = value->data[0].v_pointer;
 361
 362   return NULL;
 363 }
 364
 365 static void
 366 value_free_variant (GValue *value)
 367 {
 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);
 371 }
 372
 373 static void
 374 value_copy_variant (const GValue *src_value,
 375                    GValue       *dest_value)
 376 {
 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);
 379   else
 380     dest_value->data[0].v_pointer = NULL;
 381 }
 382
 383 static gchar*
 384 value_collect_variant (GValue     *value,
 385                       guint        n_collect_values,
 386                       GTypeCValue *collect_values,
 387                       guint        collect_flags)
 388 {
 389   if (!collect_values[0].v_pointer)
 390     value->data[0].v_pointer = NULL;
 391   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 392     {
 393       value->data[0].v_pointer = collect_values[0].v_pointer;
 394       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 395     }
 396   else
 397     value->data[0].v_pointer = g_variant_ref_sink (collect_values[0].v_pointer);
 398
 399   return NULL;
 400 }
 401
 402 static gchar*
 403 value_lcopy_variant (const GValue *value,
 404                     guint         n_collect_values,
 405                     GTypeCValue  *collect_values,
 406                     guint         collect_flags)
 407 {
 408   GVariant **variant_p = collect_values[0].v_pointer;
 409
 410   if (!variant_p)
 411     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 412
 413   if (!value->data[0].v_pointer)
 414     *variant_p = NULL;
 415   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 416     *variant_p = value->data[0].v_pointer;
 417   else
 418     *variant_p = g_variant_ref_sink (value->data[0].v_pointer);
 419
 420   return NULL;
 421 }
 422
 423 /* --- type initialization --- */
 424 void
 425 _g_value_types_init (void)
 426 {
 427   GTypeInfo info = {
 428     0,                          /* class_size */
 429     NULL,                       /* base_init */
 430     NULL,                       /* base_destroy */
 431     NULL,                       /* class_init */
 432     NULL,                       /* class_destroy */
 433     NULL,                       /* class_data */
 434     0,                          /* instance_size */
 435     0,                          /* n_preallocs */
 436     NULL,                       /* instance_init */
 437     NULL,                       /* value_table */
 438   };
 439   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
 440   GType type;
 441
 442   /* G_TYPE_CHAR / G_TYPE_UCHAR
 443    */
 444   {
 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 */
 454     };
 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);
 460   }
 461
 462   /* G_TYPE_BOOLEAN
 463    */
 464   {
 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 */
 474     };
 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);
 478   }
 479
 480   /* G_TYPE_INT / G_TYPE_UINT
 481    */
 482   {
 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 */
 492     };
 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);
 498   }
 499
 500   /* G_TYPE_LONG / G_TYPE_ULONG
 501    */
 502   {
 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 */
 512     };
 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);
 518   }
 519
 520   /* G_TYPE_INT64 / G_TYPE_UINT64
 521    */
 522   {
 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 */
 532     };
 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);
 538   }
 539
 540   /* G_TYPE_FLOAT
 541    */
 542   {
 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 */
 552     };
 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);
 556   }
 557
 558   /* G_TYPE_DOUBLE
 559    */
 560   {
 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 */
 570     };
 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);
 574   }
 575
 576   /* G_TYPE_STRING
 577    */
 578   {
 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 */
 588     };
 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);
 592   }
 593
 594   /* G_TYPE_POINTER
 595    */
 596   {
 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 */
 606     };
 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);
 610   }
 611
 612   /* G_TYPE_VARIANT
 613    */
 614   {
 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 */
 624     };
 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);
 628   }
 629 }
 630
 631
 632 /* --- GValue functions --- */
 633 /**
 634  * g_value_set_char:
 635  * @value: a valid #GValue of type %G_TYPE_CHAR
 636  * @v_char: character value to be set
 637  *
 638  * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
 639  */
 640 void
 641 g_value_set_char (GValue *value,
 642                   gchar   v_char)
 643 {
 644   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 645
 646   value->data[0].v_int = v_char;
 647 }
 648
 649 /**
 650  * g_value_get_char:
 651  * @value: a valid #GValue of type %G_TYPE_CHAR
 652  *
 653  * Get the contents of a %G_TYPE_CHAR #GValue.
 654  *
 655  * Returns: character contents of @value
 656  */
 657 gchar
 658 g_value_get_char (const GValue *value)
 659 {
 660   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 661
 662   return value->data[0].v_int;
 663 }
 664
 665 /**
 666  * g_value_set_uchar:
 667  * @value: a valid #GValue of type %G_TYPE_UCHAR
 668  * @v_uchar: unsigned character value to be set
 669  *
 670  * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
 671  */
 672 void
 673 g_value_set_uchar (GValue *value,
 674                    guchar  v_uchar)
 675 {
 676   g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
 677
 678   value->data[0].v_uint = v_uchar;
 679 }
 680
 681 /**
 682  * g_value_get_uchar:
 683  * @value: a valid #GValue of type %G_TYPE_UCHAR
 684  *
 685  * Get the contents of a %G_TYPE_UCHAR #GValue.
 686  *
 687  * Returns: unsigned character contents of @value
 688  */
 689 guchar
 690 g_value_get_uchar (const GValue *value)
 691 {
 692   g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
 693
 694   return value->data[0].v_uint;
 695 }
 696
 697 /**
 698  * g_value_set_boolean:
 699  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 700  * @v_boolean: boolean value to be set
 701  *
 702  * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
 703  */
 704 void
 705 g_value_set_boolean (GValue  *value,
 706                      gboolean v_boolean)
 707 {
 708   g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
 709
 710   value->data[0].v_int = v_boolean != FALSE;
 711 }
 712
 713 /**
 714  * g_value_get_boolean:
 715  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 716  *
 717  * Get the contents of a %G_TYPE_BOOLEAN #GValue.
 718  *
 719  * Returns: boolean contents of @value
 720  */
 721 gboolean
 722 g_value_get_boolean (const GValue *value)
 723 {
 724   g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
 725
 726   return value->data[0].v_int;
 727 }
 728
 729 /**
 730  * g_value_set_int:
 731  * @value: a valid #GValue of type %G_TYPE_INT
 732  * @v_int: integer value to be set
 733  *
 734  * Set the contents of a %G_TYPE_INT #GValue to @v_int.
 735  */
 736 void
 737 g_value_set_int (GValue *value,
 738                  gint    v_int)
 739 {
 740   g_return_if_fail (G_VALUE_HOLDS_INT (value));
 741
 742   value->data[0].v_int = v_int;
 743 }
 744
 745 /**
 746  * g_value_get_int:
 747  * @value: a valid #GValue of type %G_TYPE_INT
 748  *
 749  * Get the contents of a %G_TYPE_INT #GValue.
 750  *
 751  * Returns: integer contents of @value
 752  */
 753 gint
 754 g_value_get_int (const GValue *value)
 755 {
 756   g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
 757
 758   return value->data[0].v_int;
 759 }
 760
 761 /**
 762  * g_value_set_uint:
 763  * @value: a valid #GValue of type %G_TYPE_UINT
 764  * @v_uint: unsigned integer value to be set
 765  *
 766  * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
 767  */
 768 void
 769 g_value_set_uint (GValue *value,
 770                   guint   v_uint)
 771 {
 772   g_return_if_fail (G_VALUE_HOLDS_UINT (value));
 773
 774   value->data[0].v_uint = v_uint;
 775 }
 776
 777 /**
 778  * g_value_get_uint:
 779  * @value: a valid #GValue of type %G_TYPE_UINT
 780  *
 781  * Get the contents of a %G_TYPE_UINT #GValue.
 782  *
 783  * Returns: unsigned integer contents of @value
 784  */
 785 guint
 786 g_value_get_uint (const GValue *value)
 787 {
 788   g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
 789
 790   return value->data[0].v_uint;
 791 }
 792
 793 /**
 794  * g_value_set_long:
 795  * @value: a valid #GValue of type %G_TYPE_LONG
 796  * @v_long: long integer value to be set
 797  *
 798  * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
 799  */
 800 void
 801 g_value_set_long (GValue *value,
 802                   glong   v_long)
 803 {
 804   g_return_if_fail (G_VALUE_HOLDS_LONG (value));
 805
 806   value->data[0].v_long = v_long;
 807 }
 808
 809 /**
 810  * g_value_get_long:
 811  * @value: a valid #GValue of type %G_TYPE_LONG
 812  *
 813  * Get the contents of a %G_TYPE_LONG #GValue.
 814  *
 815  * Returns: long integer contents of @value
 816  */
 817 glong
 818 g_value_get_long (const GValue *value)
 819 {
 820   g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
 821
 822   return value->data[0].v_long;
 823 }
 824
 825 /**
 826  * g_value_set_ulong:
 827  * @value: a valid #GValue of type %G_TYPE_ULONG
 828  * @v_ulong: unsigned long integer value to be set
 829  *
 830  * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
 831  */
 832 void
 833 g_value_set_ulong (GValue *value,
 834                    gulong  v_ulong)
 835 {
 836   g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
 837
 838   value->data[0].v_ulong = v_ulong;
 839 }
 840
 841 /**
 842  * g_value_get_ulong:
 843  * @value: a valid #GValue of type %G_TYPE_ULONG
 844  *
 845  * Get the contents of a %G_TYPE_ULONG #GValue.
 846  *
 847  * Returns: unsigned long integer contents of @value
 848  */
 849 gulong
 850 g_value_get_ulong (const GValue *value)
 851 {
 852   g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
 853
 854   return value->data[0].v_ulong;
 855 }
 856
 857 /**
 858  * g_value_get_int64:
 859  * @value: a valid #GValue of type %G_TYPE_INT64
 860  *
 861  * Get the contents of a %G_TYPE_INT64 #GValue.
 862  *
 863  * Returns: 64bit integer contents of @value
 864  */
 865 void
 866 g_value_set_int64 (GValue *value,
 867                    gint64  v_int64)
 868 {
 869   g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
 870
 871   value->data[0].v_int64 = v_int64;
 872 }
 873
 874 /**
 875  * g_value_set_int64:
 876  * @value: a valid #GValue of type %G_TYPE_INT64
 877  * @v_int64: 64bit integer value to be set
 878  *
 879  * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
 880  */
 881 gint64
 882 g_value_get_int64 (const GValue *value)
 883 {
 884   g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
 885
 886   return value->data[0].v_int64;
 887 }
 888
 889 /**
 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
 893  *
 894  * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
 895  */
 896 void
 897 g_value_set_uint64 (GValue *value,
 898                     guint64 v_uint64)
 899 {
 900   g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
 901
 902   value->data[0].v_uint64 = v_uint64;
 903 }
 904
 905 /**
 906  * g_value_get_uint64:
 907  * @value: a valid #GValue of type %G_TYPE_UINT64
 908  *
 909  * Get the contents of a %G_TYPE_UINT64 #GValue.
 910  *
 911  * Returns: unsigned 64bit integer contents of @value
 912  */
 913 guint64
 914 g_value_get_uint64 (const GValue *value)
 915 {
 916   g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
 917
 918   return value->data[0].v_uint64;
 919 }
 920
 921 /**
 922  * g_value_set_float:
 923  * @value: a valid #GValue of type %G_TYPE_FLOAT
 924  * @v_float: float value to be set
 925  *
 926  * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
 927  */
 928 void
 929 g_value_set_float (GValue *value,
 930                    gfloat  v_float)
 931 {
 932   g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
 933
 934   value->data[0].v_float = v_float;
 935 }
 936
 937 /**
 938  * g_value_get_float:
 939  * @value: a valid #GValue of type %G_TYPE_FLOAT
 940  *
 941  * Get the contents of a %G_TYPE_FLOAT #GValue.
 942  *
 943  * Returns: float contents of @value
 944  */
 945 gfloat
 946 g_value_get_float (const GValue *value)
 947 {
 948   g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
 949
 950   return value->data[0].v_float;
 951 }
 952
 953 /**
 954  * g_value_set_double:
 955  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 956  * @v_double: double value to be set
 957  *
 958  * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
 959  */
 960 void
 961 g_value_set_double (GValue *value,
 962                     gdouble v_double)
 963 {
 964   g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
 965
 966   value->data[0].v_double = v_double;
 967 }
 968
 969 /**
 970  * g_value_get_double:
 971  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 972  *
 973  * Get the contents of a %G_TYPE_DOUBLE #GValue.
 974  *
 975  * Returns: double contents of @value
 976  */
 977 gdouble
 978 g_value_get_double (const GValue *value)
 979 {
 980   g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
 981
 982   return value->data[0].v_double;
 983 }
 984
 985 /**
 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
 989  *
 990  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 991  */
 992 void
 993 g_value_set_string (GValue      *value,
 994                     const gchar *v_string)
 995 {
 996   gchar *new_val;
 997
 998   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 999
1000   new_val = g_strdup (v_string);
1001
1002   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1003     value->data[1].v_uint = 0;
1004   else
1005     g_free (value->data[0].v_pointer);
1006
1007   value->data[0].v_pointer = new_val;
1008 }
1009
1010 /**
1011  * g_value_set_static_string:
1012  * @value: a valid #GValue of type %G_TYPE_STRING
1013  * @v_string: static string to be set
1014  *
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.
1018  */
1019 void
1020 g_value_set_static_string (GValue      *value,
1021                            const gchar *v_string)
1022 {
1023   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1024
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;
1029 }
1030
1031 /**
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
1035  *
1036  * This is an internal function introduced mainly for C marshallers.
1037  *
1038  * Deprecated: 2.4: Use g_value_take_string() instead.
1039  */
1040 void
1041 g_value_set_string_take_ownership (GValue *value,
1042                                    gchar  *v_string)
1043 {
1044   g_value_take_string (value, v_string);
1045 }
1046
1047 /**
1048  * g_value_take_string:
1049  * @value: a valid #GValue of type %G_TYPE_STRING
1050  * @v_string: string to take ownership of
1051  *
1052  * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1053  *
1054  * Since: 2.4
1055  */
1056 void
1057 g_value_take_string (GValue *value,
1058                      gchar  *v_string)
1059 {
1060   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1061
1062   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1063     value->data[1].v_uint = 0;
1064   else
1065     g_free (value->data[0].v_pointer);
1066   value->data[0].v_pointer = v_string;
1067 }
1068
1069 /**
1070  * g_value_get_string:
1071  * @value: a valid #GValue of type %G_TYPE_STRING
1072  *
1073  * Get the contents of a %G_TYPE_STRING #GValue.
1074  *
1075  * Returns: string content of @value
1076  */
1077 const gchar*
1078 g_value_get_string (const GValue *value)
1079 {
1080   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1081
1082   return value->data[0].v_pointer;
1083 }
1084
1085 /**
1086  * g_value_dup_string:
1087  * @value: a valid #GValue of type %G_TYPE_STRING
1088  *
1089  * Get a copy the contents of a %G_TYPE_STRING #GValue.
1090  *
1091  * Returns: a newly allocated copy of the string content of @value
1092  */
1093 gchar*
1094 g_value_dup_string (const GValue *value)
1095 {
1096   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1097
1098   return g_strdup (value->data[0].v_pointer);
1099 }
1100
1101 /**
1102  * g_value_set_pointer:
1103  * @value: a valid #GValue of %G_TYPE_POINTER
1104  * @v_pointer: pointer value to be set
1105  *
1106  * Set the contents of a pointer #GValue to @v_pointer.
1107  */
1108 void
1109 g_value_set_pointer (GValue  *value,
1110                      gpointer v_pointer)
1111 {
1112   g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1113
1114   value->data[0].v_pointer = v_pointer;
1115 }
1116
1117 /**
1118  * g_value_get_pointer:
1119  * @value: a valid #GValue of %G_TYPE_POINTER
1120  *
1121  * Get the contents of a pointer #GValue.
1122  *
1123  * Returns: (transfer none): pointer contents of @value
1124  */
1125 gpointer
1126 g_value_get_pointer (const GValue *value)
1127 {
1128   g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1129
1130   return value->data[0].v_pointer;
1131 }
1132
1133 G_DEFINE_POINTER_TYPE (GType, g_gtype)
1134
1135 /**
1136  * g_value_set_gtype:
1137  * @value: a valid #GValue of type %G_TYPE_GTYPE
1138  * @v_gtype: #GType to be set
1139  *
1140  * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1141  *
1142  * Since: 2.12
1143  */
1144 void
1145 g_value_set_gtype (GValue *value,
1146                    GType   v_gtype)
1147 {
1148   g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1149
1150   value->data[0].v_long = v_gtype;
1151
1152 }
1153
1154 /**
1155  * g_value_get_gtype:
1156  * @value: a valid #GValue of type %G_TYPE_GTYPE
1157  *
1158  * Get the contents of a %G_TYPE_GTYPE #GValue.
1159  *
1160  * Since: 2.12
1161  *
1162  * Returns: the #GType stored in @value
1163  */
1164 GType
1165 g_value_get_gtype (const GValue *value)
1166 {
1167   g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1168
1169   return value->data[0].v_long;
1170 }
1171
1172 /**
1173  * g_value_set_variant:
1174  * @value: a valid #GValue of type %G_TYPE_VARIANT
1175  * @variant: a #GVariant, or %NULL
1176  *
1177  * Set the contents of a variant #GValue to @variant.
1178  * If the variant is floating, it is consumed.
1179  *
1180  * Since: 2.26
1181  */
1182 void
1183 g_value_set_variant (GValue   *value,
1184                      GVariant *variant)
1185 {
1186   GVariant *old_variant;
1187
1188   g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1189
1190   old_variant = value->data[0].v_pointer;
1191
1192   if (variant)
1193     value->data[0].v_pointer = g_variant_ref_sink (variant);
1194   else
1195     value->data[0].v_pointer = NULL;
1196
1197   if (old_variant)
1198     g_variant_unref (old_variant);
1199 }
1200
1201 /**
1202  * g_value_take_variant:
1203  * @value: a valid #GValue of type %G_TYPE_VARIANT
1204  * @variant: a #GVariant, or %NULL
1205  *
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).
1210  *
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
1214  * variants.
1215  *
1216  * If you want the #GValue to hold its own reference to @variant, use
1217  * g_value_set_variant() instead.
1218  *
1219  * This is an internal function introduced mainly for C marshallers.
1220  *
1221  * Since: 2.26
1222  */
1223 void
1224 g_value_take_variant (GValue   *value,
1225                       GVariant *variant)
1226 {
1227   GVariant *old_variant;
1228
1229   g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1230   g_return_if_fail (variant == NULL || !g_variant_is_floating (variant));
1231
1232   old_variant = value->data[0].v_pointer;
1233
1234   value->data[0].v_pointer = variant;
1235
1236   if (old_variant)
1237     g_variant_unref (old_variant);
1238 }
1239
1240 /**
1241  * g_value_get_variant:
1242  * @value: a valid #GValue of type %G_TYPE_VARIANT
1243  *
1244  * Get the contents of a variant #GValue.
1245  *
1246  * Returns: variant contents of @value
1247  *
1248  * Since: 2.26
1249  */
1250 GVariant*
1251 g_value_get_variant (const GValue *value)
1252 {
1253   g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1254
1255   return value->data[0].v_pointer;
1256 }
1257
1258 /**
1259  * g_value_dup_variant:
1260  * @value: a valid #GValue of type %G_TYPE_VARIANT
1261  *
1262  * Get the contents of a variant #GValue, increasing its refcount.
1263  *
1264  * Returns: variant contents of @value, should be unrefed using
1265  *   g_variant_unref() when no longer needed
1266  *
1267  * Since: 2.26
1268  */
1269 GVariant*
1270 g_value_dup_variant (const GValue *value)
1271 {
1272   GVariant *variant;
1273
1274   g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1275
1276   variant = value->data[0].v_pointer;
1277   if (variant)
1278     g_variant_ref_sink (variant);
1279
1280   return variant;
1281 }
1282
1283 /**
1284  * g_strdup_value_contents:
1285  * @value: #GValue which contents are to be described.
1286  *
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.
1291  *
1292  * Returns: Newly allocated string.
1293  */
1294 gchar*
1295 g_strdup_value_contents (const GValue *value)
1296 {
1297   const gchar *src;
1298   gchar *contents;
1299
1300   g_return_val_if_fail (G_IS_VALUE (value), NULL);
1301
1302   if (G_VALUE_HOLDS_STRING (value))
1303     {
1304       src = g_value_get_string (value);
1305
1306       if (!src)
1307         contents = g_strdup ("NULL");
1308       else
1309         {
1310           gchar *s = g_strescape (src, NULL);
1311
1312           contents = g_strdup_printf ("\"%s\"", s);
1313           g_free (s);
1314         }
1315     }
1316   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1317     {
1318       GValue tmp_value = { 0, };
1319       gchar *s;
1320
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)),
1328                                     s);
1329       else
1330         contents = g_strdup (s ? s : "NULL");
1331       g_free (s);
1332     }
1333   else if (g_value_fits_pointer (value))
1334     {
1335       gpointer p = g_value_peek_pointer (value);
1336
1337       if (!p)
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))
1344         {
1345           GStrv strv = g_value_get_boxed (value);
1346           GString *tmp = g_string_new ("[");
1347
1348           while (*strv != NULL)
1349             {
1350               gchar *escaped = g_strescape (*strv, NULL);
1351
1352               g_string_append_printf (tmp, "\"%s\"", escaped);
1353               g_free (escaped);
1354
1355               if (*++strv != NULL)
1356                 g_string_append (tmp, ", ");
1357             }
1358
1359           g_string_append (tmp, "]");
1360           contents = g_string_free (tmp, FALSE);
1361         }
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);
1366       else
1367         contents = g_strdup ("???");
1368     }
1369   else
1370     contents = g_strdup ("???");
1371
1372   return contents;
1373 }
1374
1375 /**
1376  * g_pointer_type_register_static:
1377  * @name: the name of the new pointer type.
1378  *
1379  * Creates a new %G_TYPE_POINTER derived type id for a new
1380  * pointer type with name @name.
1381  *
1382  * Returns: a new %G_TYPE_POINTER derived type id for @name.
1383  */
1384 GType
1385 g_pointer_type_register_static (const gchar *name)
1386 {
1387   static const GTypeInfo type_info = {
1388     0,                  /* class_size */
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 */
1398   };
1399   GType type;
1400
1401   g_return_val_if_fail (name != NULL, 0);
1402   g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1403
1404   type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
1405
1406   return type;
1407 }