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  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General
  15  * Public License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * MT safe
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h> /* qsort() */
  28
  29 #include "gvaluetypes.h"
  30 #include "gvaluecollector.h"
  31 #include "gobject.h"
  32 #include "gparam.h"
  33 #include "gboxed.h"
  34 #include "genums.h"
  35 #include "gobjectalias.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
 365 /* --- type initialization --- */
 366 void
 367 g_value_types_init (void)
 368 {
 369   GTypeInfo info = {
 370     0,                          /* class_size */
 371     NULL,                       /* base_init */
 372     NULL,                       /* base_destroy */
 373     NULL,                       /* class_init */
 374     NULL,                       /* class_destroy */
 375     NULL,                       /* class_data */
 376     0,                          /* instance_size */
 377     0,                          /* n_preallocs */
 378     NULL,                       /* instance_init */
 379     NULL,                       /* value_table */
 380   };
 381   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
 382   GType type;
 383
 384   /* G_TYPE_CHAR / G_TYPE_UCHAR
 385    */
 386   {
 387     static const GTypeValueTable value_table = {
 388       value_init_long0,         /* value_init */
 389       NULL,                     /* value_free */
 390       value_copy_long0,         /* value_copy */
 391       NULL,                     /* value_peek_pointer */
 392       "i",                      /* collect_format */
 393       value_collect_int,        /* collect_value */
 394       "p",                      /* lcopy_format */
 395       value_lcopy_char,         /* lcopy_value */
 396     };
 397     info.value_table = &value_table;
 398     type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
 399     g_assert (type == G_TYPE_CHAR);
 400     type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
 401     g_assert (type == G_TYPE_UCHAR);
 402   }
 403
 404   /* G_TYPE_BOOLEAN
 405    */
 406   {
 407     static const GTypeValueTable value_table = {
 408       value_init_long0,          /* value_init */
 409       NULL,                      /* value_free */
 410       value_copy_long0,          /* value_copy */
 411       NULL,                      /* value_peek_pointer */
 412       "i",                       /* collect_format */
 413       value_collect_int,         /* collect_value */
 414       "p",                       /* lcopy_format */
 415       value_lcopy_boolean,       /* lcopy_value */
 416     };
 417     info.value_table = &value_table;
 418     type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
 419     g_assert (type == G_TYPE_BOOLEAN);
 420   }
 421
 422   /* G_TYPE_INT / G_TYPE_UINT
 423    */
 424   {
 425     static const GTypeValueTable value_table = {
 426       value_init_long0,         /* value_init */
 427       NULL,                     /* value_free */
 428       value_copy_long0,         /* value_copy */
 429       NULL,                     /* value_peek_pointer */
 430       "i",                      /* collect_format */
 431       value_collect_int,        /* collect_value */
 432       "p",                      /* lcopy_format */
 433       value_lcopy_int,          /* lcopy_value */
 434     };
 435     info.value_table = &value_table;
 436     type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
 437     g_assert (type == G_TYPE_INT);
 438     type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
 439     g_assert (type == G_TYPE_UINT);
 440   }
 441
 442   /* G_TYPE_LONG / G_TYPE_ULONG
 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       "l",                      /* collect_format */
 451       value_collect_long,       /* collect_value */
 452       "p",                      /* lcopy_format */
 453       value_lcopy_long,         /* lcopy_value */
 454     };
 455     info.value_table = &value_table;
 456     type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
 457     g_assert (type == G_TYPE_LONG);
 458     type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
 459     g_assert (type == G_TYPE_ULONG);
 460   }
 461
 462   /* G_TYPE_INT64 / G_TYPE_UINT64
 463    */
 464   {
 465     static const GTypeValueTable value_table = {
 466       value_init_int64,         /* value_init */
 467       NULL,                     /* value_free */
 468       value_copy_int64,         /* value_copy */
 469       NULL,                     /* value_peek_pointer */
 470       "q",                      /* collect_format */
 471       value_collect_int64,      /* collect_value */
 472       "p",                      /* lcopy_format */
 473       value_lcopy_int64,        /* lcopy_value */
 474     };
 475     info.value_table = &value_table;
 476     type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
 477     g_assert (type == G_TYPE_INT64);
 478     type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
 479     g_assert (type == G_TYPE_UINT64);
 480   }
 481
 482   /* G_TYPE_FLOAT
 483    */
 484   {
 485     static const GTypeValueTable value_table = {
 486       value_init_float,          /* value_init */
 487       NULL,                      /* value_free */
 488       value_copy_float,          /* value_copy */
 489       NULL,                      /* value_peek_pointer */
 490       "d",                       /* collect_format */
 491       value_collect_float,       /* collect_value */
 492       "p",                       /* lcopy_format */
 493       value_lcopy_float,         /* lcopy_value */
 494     };
 495     info.value_table = &value_table;
 496     type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
 497     g_assert (type == G_TYPE_FLOAT);
 498   }
 499
 500   /* G_TYPE_DOUBLE
 501    */
 502   {
 503     static const GTypeValueTable value_table = {
 504       value_init_double,        /* value_init */
 505       NULL,                     /* value_free */
 506       value_copy_double,        /* value_copy */
 507       NULL,                     /* value_peek_pointer */
 508       "d",                      /* collect_format */
 509       value_collect_double,     /* collect_value */
 510       "p",                      /* lcopy_format */
 511       value_lcopy_double,       /* lcopy_value */
 512     };
 513     info.value_table = &value_table;
 514     type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
 515     g_assert (type == G_TYPE_DOUBLE);
 516   }
 517
 518   /* G_TYPE_STRING
 519    */
 520   {
 521     static const GTypeValueTable value_table = {
 522       value_init_string,        /* value_init */
 523       value_free_string,        /* value_free */
 524       value_copy_string,        /* value_copy */
 525       value_peek_pointer0,      /* value_peek_pointer */
 526       "p",                      /* collect_format */
 527       value_collect_string,     /* collect_value */
 528       "p",                      /* lcopy_format */
 529       value_lcopy_string,       /* lcopy_value */
 530     };
 531     info.value_table = &value_table;
 532     type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
 533     g_assert (type == G_TYPE_STRING);
 534   }
 535
 536   /* G_TYPE_POINTER
 537    */
 538   {
 539     static const GTypeValueTable value_table = {
 540       value_init_pointer,       /* value_init */
 541       NULL,                     /* value_free */
 542       value_copy_pointer,       /* value_copy */
 543       value_peek_pointer0,      /* value_peek_pointer */
 544       "p",                      /* collect_format */
 545       value_collect_pointer,    /* collect_value */
 546       "p",                      /* lcopy_format */
 547       value_lcopy_pointer,      /* lcopy_value */
 548     };
 549     info.value_table = &value_table;
 550     type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
 551     g_assert (type == G_TYPE_POINTER);
 552   }
 553 }
 554
 555
 556 /* --- GValue functions --- */
 557 /**
 558  * g_value_set_char:
 559  * @value: a valid #GValue of type %G_TYPE_CHAR
 560  * @v_char: character value to be set
 561  *
 562  * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
 563  */
 564 void
 565 g_value_set_char (GValue *value,
 566                   gchar   v_char)
 567 {
 568   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 569
 570   value->data[0].v_int = v_char;
 571 }
 572
 573 /**
 574  * g_value_get_char:
 575  * @value: a valid #GValue of type %G_TYPE_CHAR
 576  *
 577  * Get the contents of a %G_TYPE_CHAR #GValue.
 578  *
 579  * Returns: character contents of @value
 580  */
 581 gchar
 582 g_value_get_char (const GValue *value)
 583 {
 584   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 585
 586   return value->data[0].v_int;
 587 }
 588
 589 /**
 590  * g_value_set_uchar:
 591  * @value: a valid #GValue of type %G_TYPE_UCHAR
 592  * @v_uchar: unsigned character value to be set
 593  *
 594  * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
 595  */
 596 void
 597 g_value_set_uchar (GValue *value,
 598                    guchar  v_uchar)
 599 {
 600   g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
 601
 602   value->data[0].v_uint = v_uchar;
 603 }
 604
 605 /**
 606  * g_value_get_uchar:
 607  * @value: a valid #GValue of type %G_TYPE_UCHAR
 608  *
 609  * Get the contents of a %G_TYPE_UCHAR #GValue.
 610  *
 611  * Returns: unsigned character contents of @value
 612  */
 613 guchar
 614 g_value_get_uchar (const GValue *value)
 615 {
 616   g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
 617
 618   return value->data[0].v_uint;
 619 }
 620
 621 /**
 622  * g_value_set_boolean:
 623  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 624  * @v_boolean: boolean value to be set
 625  *
 626  * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
 627  */
 628 void
 629 g_value_set_boolean (GValue  *value,
 630                      gboolean v_boolean)
 631 {
 632   g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
 633
 634   value->data[0].v_int = v_boolean != FALSE;
 635 }
 636
 637 /**
 638  * g_value_get_boolean:
 639  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 640  *
 641  * Get the contents of a %G_TYPE_BOOLEAN #GValue.
 642  *
 643  * Returns: boolean contents of @value
 644  */
 645 gboolean
 646 g_value_get_boolean (const GValue *value)
 647 {
 648   g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
 649
 650   return value->data[0].v_int;
 651 }
 652
 653 /**
 654  * g_value_set_int:
 655  * @value: a valid #GValue of type %G_TYPE_INT
 656  * @v_int: integer value to be set
 657  *
 658  * Set the contents of a %G_TYPE_INT #GValue to @v_int.
 659  */
 660 void
 661 g_value_set_int (GValue *value,
 662                  gint    v_int)
 663 {
 664   g_return_if_fail (G_VALUE_HOLDS_INT (value));
 665
 666   value->data[0].v_int = v_int;
 667 }
 668
 669 /**
 670  * g_value_get_int:
 671  * @value: a valid #GValue of type %G_TYPE_INT
 672  *
 673  * Get the contents of a %G_TYPE_INT #GValue.
 674  *
 675  * Returns: integer contents of @value
 676  */
 677 gint
 678 g_value_get_int (const GValue *value)
 679 {
 680   g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
 681
 682   return value->data[0].v_int;
 683 }
 684
 685 /**
 686  * g_value_set_uint:
 687  * @value: a valid #GValue of type %G_TYPE_UINT
 688  * @v_uint: unsigned integer value to be set
 689  *
 690  * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
 691  */
 692 void
 693 g_value_set_uint (GValue *value,
 694                   guint   v_uint)
 695 {
 696   g_return_if_fail (G_VALUE_HOLDS_UINT (value));
 697
 698   value->data[0].v_uint = v_uint;
 699 }
 700
 701 /**
 702  * g_value_get_uint:
 703  * @value: a valid #GValue of type %G_TYPE_UINT
 704  *
 705  * Get the contents of a %G_TYPE_UINT #GValue.
 706  *
 707  * Returns: unsigned integer contents of @value
 708  */
 709 guint
 710 g_value_get_uint (const GValue *value)
 711 {
 712   g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
 713
 714   return value->data[0].v_uint;
 715 }
 716
 717 /**
 718  * g_value_set_long:
 719  * @value: a valid #GValue of type %G_TYPE_LONG
 720  * @v_long: long integer value to be set
 721  *
 722  * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
 723  */
 724 void
 725 g_value_set_long (GValue *value,
 726                   glong   v_long)
 727 {
 728   g_return_if_fail (G_VALUE_HOLDS_LONG (value));
 729
 730   value->data[0].v_long = v_long;
 731 }
 732
 733 /**
 734  * g_value_get_long:
 735  * @value: a valid #GValue of type %G_TYPE_LONG
 736  *
 737  * Get the contents of a %G_TYPE_LONG #GValue.
 738  *
 739  * Returns: long integer contents of @value
 740  */
 741 glong
 742 g_value_get_long (const GValue *value)
 743 {
 744   g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
 745
 746   return value->data[0].v_long;
 747 }
 748
 749 /**
 750  * g_value_set_ulong:
 751  * @value: a valid #GValue of type %G_TYPE_ULONG
 752  * @v_ulong: unsigned long integer value to be set
 753  *
 754  * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
 755  */
 756 void
 757 g_value_set_ulong (GValue *value,
 758                    gulong  v_ulong)
 759 {
 760   g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
 761
 762   value->data[0].v_ulong = v_ulong;
 763 }
 764
 765 /**
 766  * g_value_get_ulong:
 767  * @value: a valid #GValue of type %G_TYPE_ULONG
 768  *
 769  * Get the contents of a %G_TYPE_ULONG #GValue.
 770  *
 771  * Returns: unsigned long integer contents of @value
 772  */
 773 gulong
 774 g_value_get_ulong (const GValue *value)
 775 {
 776   g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
 777
 778   return value->data[0].v_ulong;
 779 }
 780
 781 /**
 782  * g_value_get_int64:
 783  * @value: a valid #GValue of type %G_TYPE_INT64
 784  *
 785  * Get the contents of a %G_TYPE_INT64 #GValue.
 786  *
 787  * Returns: 64bit integer contents of @value
 788  */
 789 void
 790 g_value_set_int64 (GValue *value,
 791                    gint64  v_int64)
 792 {
 793   g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
 794
 795   value->data[0].v_int64 = v_int64;
 796 }
 797
 798 /**
 799  * g_value_set_int64:
 800  * @value: a valid #GValue of type %G_TYPE_INT64
 801  * @v_int64: 64bit integer value to be set
 802  *
 803  * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
 804  */
 805 gint64
 806 g_value_get_int64 (const GValue *value)
 807 {
 808   g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
 809
 810   return value->data[0].v_int64;
 811 }
 812
 813 /**
 814  * g_value_set_uint64:
 815  * @value: a valid #GValue of type %G_TYPE_UINT64
 816  * @v_uint64: unsigned 64bit integer value to be set
 817  *
 818  * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
 819  */
 820 void
 821 g_value_set_uint64 (GValue *value,
 822                     guint64 v_uint64)
 823 {
 824   g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
 825
 826   value->data[0].v_uint64 = v_uint64;
 827 }
 828
 829 /**
 830  * g_value_get_uint64:
 831  * @value: a valid #GValue of type %G_TYPE_UINT64
 832  *
 833  * Get the contents of a %G_TYPE_UINT64 #GValue.
 834  *
 835  * Returns: unsigned 64bit integer contents of @value
 836  */
 837 guint64
 838 g_value_get_uint64 (const GValue *value)
 839 {
 840   g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
 841
 842   return value->data[0].v_uint64;
 843 }
 844
 845 /**
 846  * g_value_set_float:
 847  * @value: a valid #GValue of type %G_TYPE_FLOAT
 848  * @v_float: float value to be set
 849  *
 850  * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
 851  */
 852 void
 853 g_value_set_float (GValue *value,
 854                    gfloat  v_float)
 855 {
 856   g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
 857
 858   value->data[0].v_float = v_float;
 859 }
 860
 861 /**
 862  * g_value_get_float:
 863  * @value: a valid #GValue of type %G_TYPE_FLOAT
 864  *
 865  * Get the contents of a %G_TYPE_FLOAT #GValue.
 866  *
 867  * Returns: float contents of @value
 868  */
 869 gfloat
 870 g_value_get_float (const GValue *value)
 871 {
 872   g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
 873
 874   return value->data[0].v_float;
 875 }
 876
 877 /**
 878  * g_value_set_double:
 879  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 880  * @v_double: double value to be set
 881  *
 882  * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
 883  */
 884 void
 885 g_value_set_double (GValue *value,
 886                     gdouble v_double)
 887 {
 888   g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
 889
 890   value->data[0].v_double = v_double;
 891 }
 892
 893 /**
 894  * g_value_get_double:
 895  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 896  *
 897  * Get the contents of a %G_TYPE_DOUBLE #GValue.
 898  *
 899  * Returns: double contents of @value
 900  */
 901 gdouble
 902 g_value_get_double (const GValue *value)
 903 {
 904   g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
 905
 906   return value->data[0].v_double;
 907 }
 908
 909 /**
 910  * g_value_set_string:
 911  * @value: a valid #GValue of type %G_TYPE_STRING
 912  * @v_string: caller-owned string to be duplicated for the #GValue
 913  *
 914  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 915  */
 916 void
 917 g_value_set_string (GValue      *value,
 918                     const gchar *v_string)
 919 {
 920   gchar *new_val;
 921
 922   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 923
 924   new_val = g_strdup (v_string);
 925
 926   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 927     value->data[1].v_uint = 0;
 928   else
 929     g_free (value->data[0].v_pointer);
 930
 931   value->data[0].v_pointer = new_val;
 932 }
 933
 934 /**
 935  * g_value_set_static_string:
 936  * @value: a valid #GValue of type %G_TYPE_STRING
 937  * @v_string: static string to be set
 938  *
 939  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 940  * The string is assumed to be static, and is thus not duplicated
 941  * when setting the #GValue.
 942  */
 943 void
 944 g_value_set_static_string (GValue      *value,
 945                            const gchar *v_string)
 946 {
 947   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 948
 949   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 950     g_free (value->data[0].v_pointer);
 951   value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 952   value->data[0].v_pointer = (gchar*) v_string;
 953 }
 954
 955 /**
 956  * g_value_set_string_take_ownership:
 957  * @value: a valid #GValue of type %G_TYPE_STRING
 958  * @v_string: duplicated unowned string to be set
 959  *
 960  * This is an internal function introduced mainly for C marshallers.
 961  *
 962  * Deprecated: 2.4: Use g_value_take_string() instead.
 963  */
 964 void
 965 g_value_set_string_take_ownership (GValue *value,
 966                                    gchar  *v_string)
 967 {
 968   g_value_take_string (value, v_string);
 969 }
 970
 971 /**
 972  * g_value_take_string:
 973  * @value: a valid #GValue of type %G_TYPE_STRING
 974  * @v_string: string to take ownership of
 975  *
 976  * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
 977  *
 978  * Since: 2.4
 979  */
 980 void
 981 g_value_take_string (GValue *value,
 982                      gchar  *v_string)
 983 {
 984   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 985
 986   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 987     value->data[1].v_uint = 0;
 988   else
 989     g_free (value->data[0].v_pointer);
 990   value->data[0].v_pointer = v_string;
 991 }
 992
 993 /**
 994  * g_value_get_string:
 995  * @value: a valid #GValue of type %G_TYPE_STRING
 996  *
 997  * Get the contents of a %G_TYPE_STRING #GValue.
 998  *
 999  * Returns: string content of @value
1000  */
1001 G_CONST_RETURN gchar*
1002 g_value_get_string (const GValue *value)
1003 {
1004   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1005
1006   return value->data[0].v_pointer;
1007 }
1008
1009 /**
1010  * g_value_dup_string:
1011  * @value: a valid #GValue of type %G_TYPE_STRING
1012  *
1013  * Get a copy the contents of a %G_TYPE_STRING #GValue.
1014  *
1015  * Returns: a newly allocated copy of the string content of @value
1016  */
1017 gchar*
1018 g_value_dup_string (const GValue *value)
1019 {
1020   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1021
1022   return g_strdup (value->data[0].v_pointer);
1023 }
1024
1025 /**
1026  * g_value_set_pointer:
1027  * @value: a valid #GValue of %G_TYPE_POINTER
1028  * @v_pointer: pointer value to be set
1029  *
1030  * Set the contents of a pointer #GValue to @v_pointer.
1031  */
1032 void
1033 g_value_set_pointer (GValue  *value,
1034                      gpointer v_pointer)
1035 {
1036   g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1037
1038   value->data[0].v_pointer = v_pointer;
1039 }
1040
1041 /**
1042  * g_value_get_pointer:
1043  * @value: a valid #GValue of %G_TYPE_POINTER
1044  *
1045  * Get the contents of a pointer #GValue.
1046  *
1047  * Returns: pointer contents of @value
1048  */
1049 gpointer
1050 g_value_get_pointer (const GValue *value)
1051 {
1052   g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1053
1054   return value->data[0].v_pointer;
1055 }
1056
1057 GType
1058 g_gtype_get_type (void)
1059 {
1060   static const GTypeInfo type_info = { 0, };
1061   static GType type;
1062   if (!type)
1063     type = g_type_register_static (G_TYPE_POINTER, g_intern_static_string ("GType"), &type_info, 0);
1064   return type;
1065 }
1066
1067 /**
1068  * g_value_set_gtype:
1069  * @value: a valid #GValue of type %G_TYPE_GTYPE
1070  * @v_gtype: #GType to be set
1071  *
1072  * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1073  *
1074  * Since: 2.12
1075  */
1076 void
1077 g_value_set_gtype (GValue *value,
1078                    GType   v_gtype)
1079 {
1080   g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1081
1082   value->data[0].v_long = v_gtype;
1083
1084 }
1085
1086 /**
1087  * g_value_get_gtype:
1088  * @value: a valid #GValue of type %G_TYPE_GTYPE
1089  *
1090  * Get the contents of a %G_TYPE_GTYPE #GValue.
1091  *
1092  * Since: 2.12
1093  *
1094  * Returns: the #GType stored in @value
1095  */
1096 GType
1097 g_value_get_gtype (const GValue *value)
1098 {
1099   g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1100
1101   return value->data[0].v_long;
1102 }
1103
1104 /**
1105  * g_strdup_value_contents:
1106  * @value: #GValue which contents are to be described.
1107  *
1108  * Return a newly allocated string, which describes the contents of a
1109  * #GValue.  The main purpose of this function is to describe #GValue
1110  * contents for debugging output, the way in which the contents are
1111  * described may change between different GLib versions.
1112  *
1113  * Returns: Newly allocated string.
1114  */
1115 gchar*
1116 g_strdup_value_contents (const GValue *value)
1117 {
1118   const gchar *src;
1119   gchar *contents;
1120
1121   g_return_val_if_fail (G_IS_VALUE (value), NULL);
1122
1123   if (G_VALUE_HOLDS_STRING (value))
1124     {
1125       src = g_value_get_string (value);
1126
1127       if (!src)
1128         contents = g_strdup ("NULL");
1129       else
1130         {
1131           gchar *s = g_strescape (src, NULL);
1132
1133           contents = g_strdup_printf ("\"%s\"", s);
1134           g_free (s);
1135         }
1136     }
1137   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1138     {
1139       GValue tmp_value = { 0, };
1140       gchar *s;
1141
1142       g_value_init (&tmp_value, G_TYPE_STRING);
1143       g_value_transform (value, &tmp_value);
1144       s = g_strescape (g_value_get_string (&tmp_value), NULL);
1145       g_value_unset (&tmp_value);
1146       if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
1147         contents = g_strdup_printf ("((%s) %s)",
1148                                     g_type_name (G_VALUE_TYPE (value)),
1149                                     s);
1150       else
1151         contents = g_strdup (s ? s : "NULL");
1152       g_free (s);
1153     }
1154   else if (g_value_fits_pointer (value))
1155     {
1156       gpointer p = g_value_peek_pointer (value);
1157
1158       if (!p)
1159         contents = g_strdup ("NULL");
1160       else if (G_VALUE_HOLDS_OBJECT (value))
1161         contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
1162       else if (G_VALUE_HOLDS_PARAM (value))
1163         contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
1164       else if (G_VALUE_HOLDS_BOXED (value))
1165         contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
1166       else if (G_VALUE_HOLDS_POINTER (value))
1167         contents = g_strdup_printf ("((gpointer) %p)", p);
1168       else
1169         contents = g_strdup ("???");
1170     }
1171   else
1172     contents = g_strdup ("???");
1173
1174   return contents;
1175 }
1176
1177 /**
1178  * g_pointer_type_register_static:
1179  * @name: the name of the new pointer type.
1180  *
1181  * Creates a new %G_TYPE_POINTER derived type id for a new
1182  * pointer type with name @name.
1183  *
1184  * Returns: a new %G_TYPE_POINTER derived type id for @name.
1185  */
1186 GType
1187 g_pointer_type_register_static (const gchar *name)
1188 {
1189   static const GTypeInfo type_info = {
1190     0,                  /* class_size */
1191     NULL,               /* base_init */
1192     NULL,               /* base_finalize */
1193     NULL,               /* class_init */
1194     NULL,               /* class_finalize */
1195     NULL,               /* class_data */
1196     0,                  /* instance_size */
1197     0,                  /* n_preallocs */
1198     NULL,               /* instance_init */
1199     NULL                /* value_table */
1200   };
1201   GType type;
1202
1203   g_return_val_if_fail (name != NULL, 0);
1204   g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1205
1206   type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
1207
1208   return type;
1209 }
1210
1211 #define __G_VALUETYPES_C__
1212 #include "gobjectaliasdef.c"