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" 1213
