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