luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-02 15:46:17 +01:00
Code Issues Packages Projects Releases Wiki Activity
5b48dc40cc
glib/gobject/gvaluetypes.c
Dan Winship 4b94c0831e Use 'dumb quotes' rather than `really dumb quotes' 
Back in the far-off twentieth century, it was normal on unix
workstations for U+0060 GRAVE ACCENT to be drawn as "‛" and for U+0027
APOSTROPHE to be drawn as "’". This led to the convention of using
them as poor-man's ‛smart quotes’ in ASCII-only text.

However, "'" is now universally drawn as a vertical line, and "`" at a
45-degree angle, making them an `odd couple' when used together.

Unfortunately, there are lots of very old strings in glib, and also
lots of new strings in which people have kept up the old tradition,
perhaps entirely unaware that it used to not look stupid.

Fix this by just using 'dumb quotes' everywhere.

https://bugzilla.gnome.org/show_bug.cgi?id=700746
2013-05-21 11:23:22 -03:00

1448 lines
35 KiB
C
Raw Blame History

/* GObject - GLib Type, Object, Parameter and Signal Library
* Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
* Copyright © 2010 Christian Persch
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* MT safe
*/
#include "config.h"
#include <string.h>
#include <stdlib.h> /* qsort() */
#include "gvaluetypes.h"
#include "gtype-private.h"
#include "gvaluecollector.h"
#include "gobject.h"
#include "gparam.h"
#include "gboxed.h"
#include "genums.h"
/* --- value functions --- */
static void
value_init_long0 (GValue *value)
{
value->data[0].v_long = 0;
}
static void
value_copy_long0 (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_long = src_value->data[0].v_long;
}
static gchar*
value_lcopy_char (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gint8 *int8_p = collect_values[0].v_pointer;
if (!int8_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int8_p = value->data[0].v_int;
return NULL;
}
static gchar*
value_lcopy_boolean (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gboolean *bool_p = collect_values[0].v_pointer;
if (!bool_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*bool_p = value->data[0].v_int;
return NULL;
}
static gchar*
value_collect_int (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_int = collect_values[0].v_int;
return NULL;
}
static gchar*
value_lcopy_int (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gint *int_p = collect_values[0].v_pointer;
if (!int_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int_p = value->data[0].v_int;
return NULL;
}
static gchar*
value_collect_long (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_long = collect_values[0].v_long;
return NULL;
}
static gchar*
value_lcopy_long (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
glong *long_p = collect_values[0].v_pointer;
if (!long_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*long_p = value->data[0].v_long;
return NULL;
}
static void
value_init_int64 (GValue *value)
{
value->data[0].v_int64 = 0;
}
static void
value_copy_int64 (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_int64 = src_value->data[0].v_int64;
}
static gchar*
value_collect_int64 (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_int64 = collect_values[0].v_int64;
return NULL;
}
static gchar*
value_lcopy_int64 (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gint64 *int64_p = collect_values[0].v_pointer;
if (!int64_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int64_p = value->data[0].v_int64;
return NULL;
}
static void
value_init_float (GValue *value)
{
value->data[0].v_float = 0.0;
}
static void
value_copy_float (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_float = src_value->data[0].v_float;
}
static gchar*
value_collect_float (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_float = collect_values[0].v_double;
return NULL;
}
static gchar*
value_lcopy_float (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gfloat *float_p = collect_values[0].v_pointer;
if (!float_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*float_p = value->data[0].v_float;
return NULL;
}
static void
value_init_double (GValue *value)
{
value->data[0].v_double = 0.0;
}
static void
value_copy_double (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_double = src_value->data[0].v_double;
}
static gchar*
value_collect_double (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_double = collect_values[0].v_double;
return NULL;
}
static gchar*
value_lcopy_double (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gdouble *double_p = collect_values[0].v_pointer;
if (!double_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*double_p = value->data[0].v_double;
return NULL;
}
static void
value_init_string (GValue *value)
{
value->data[0].v_pointer = NULL;
}
static void
value_free_string (GValue *value)
{
if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
g_free (value->data[0].v_pointer);
}
static void
value_copy_string (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
}
static gchar*
value_collect_string (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
if (!collect_values[0].v_pointer)
value->data[0].v_pointer = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
{
value->data[0].v_pointer = collect_values[0].v_pointer;
value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
}
else
value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
return NULL;
}
static gchar*
value_lcopy_string (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gchar **string_p = collect_values[0].v_pointer;
if (!string_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*string_p = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
*string_p = value->data[0].v_pointer;
else
*string_p = g_strdup (value->data[0].v_pointer);
return NULL;
}
static void
value_init_pointer (GValue *value)
{
value->data[0].v_pointer = NULL;
}
static void
value_copy_pointer (const GValue *src_value,
GValue *dest_value)
{
dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
}
static gpointer
value_peek_pointer0 (const GValue *value)
{
return value->data[0].v_pointer;
}
static gchar*
value_collect_pointer (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_pointer = collect_values[0].v_pointer;
return NULL;
}
static gchar*
value_lcopy_pointer (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
gpointer *pointer_p = collect_values[0].v_pointer;
if (!pointer_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*pointer_p = value->data[0].v_pointer;
return NULL;
}
static void
value_free_variant (GValue *value)
{
if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) &&
value->data[0].v_pointer)
g_variant_unref (value->data[0].v_pointer);
}
static void
value_copy_variant (const GValue *src_value,
GValue *dest_value)
{
if (src_value->data[0].v_pointer)
dest_value->data[0].v_pointer = g_variant_ref_sink (src_value->data[0].v_pointer);
else
dest_value->data[0].v_pointer = NULL;
}
static gchar*
value_collect_variant (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
if (!collect_values[0].v_pointer)
value->data[0].v_pointer = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
{
value->data[0].v_pointer = collect_values[0].v_pointer;
value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
}
else
value->data[0].v_pointer = g_variant_ref_sink (collect_values[0].v_pointer);
return NULL;
}
static gchar*
value_lcopy_variant (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
GVariant **variant_p = collect_values[0].v_pointer;
if (!variant_p)
return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*variant_p = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
*variant_p = value->data[0].v_pointer;
else
*variant_p = g_variant_ref_sink (value->data[0].v_pointer);
return NULL;
}
/* --- type initialization --- */
void
_g_value_types_init (void)
{
GTypeInfo info = {
0, /* class_size */
NULL, /* base_init */
NULL, /* base_destroy */
NULL, /* class_init */
NULL, /* class_destroy */
NULL, /* class_data */
0, /* instance_size */
0, /* n_preallocs */
NULL, /* instance_init */
NULL, /* value_table */
};
const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
GType type;
/* G_TYPE_CHAR / G_TYPE_UCHAR
*/
{
static const GTypeValueTable value_table = {
value_init_long0, /* value_init */
NULL, /* value_free */
value_copy_long0, /* value_copy */
NULL, /* value_peek_pointer */
"i", /* collect_format */
value_collect_int, /* collect_value */
"p", /* lcopy_format */
value_lcopy_char, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
g_assert (type == G_TYPE_CHAR);
type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
g_assert (type == G_TYPE_UCHAR);
}
/* G_TYPE_BOOLEAN
*/
{
static const GTypeValueTable value_table = {
value_init_long0, /* value_init */
NULL, /* value_free */
value_copy_long0, /* value_copy */
NULL, /* value_peek_pointer */
"i", /* collect_format */
value_collect_int, /* collect_value */
"p", /* lcopy_format */
value_lcopy_boolean, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
g_assert (type == G_TYPE_BOOLEAN);
}
/* G_TYPE_INT / G_TYPE_UINT
*/
{
static const GTypeValueTable value_table = {
value_init_long0, /* value_init */
NULL, /* value_free */
value_copy_long0, /* value_copy */
NULL, /* value_peek_pointer */
"i", /* collect_format */
value_collect_int, /* collect_value */
"p", /* lcopy_format */
value_lcopy_int, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
g_assert (type == G_TYPE_INT);
type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
g_assert (type == G_TYPE_UINT);
}
/* G_TYPE_LONG / G_TYPE_ULONG
*/
{
static const GTypeValueTable value_table = {
value_init_long0, /* value_init */
NULL, /* value_free */
value_copy_long0, /* value_copy */
NULL, /* value_peek_pointer */
"l", /* collect_format */
value_collect_long, /* collect_value */
"p", /* lcopy_format */
value_lcopy_long, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
g_assert (type == G_TYPE_LONG);
type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
g_assert (type == G_TYPE_ULONG);
}
/* G_TYPE_INT64 / G_TYPE_UINT64
*/
{
static const GTypeValueTable value_table = {
value_init_int64, /* value_init */
NULL, /* value_free */
value_copy_int64, /* value_copy */
NULL, /* value_peek_pointer */
"q", /* collect_format */
value_collect_int64, /* collect_value */
"p", /* lcopy_format */
value_lcopy_int64, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
g_assert (type == G_TYPE_INT64);
type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
g_assert (type == G_TYPE_UINT64);
}
/* G_TYPE_FLOAT
*/
{
static const GTypeValueTable value_table = {
value_init_float, /* value_init */
NULL, /* value_free */
value_copy_float, /* value_copy */
NULL, /* value_peek_pointer */
"d", /* collect_format */
value_collect_float, /* collect_value */
"p", /* lcopy_format */
value_lcopy_float, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
g_assert (type == G_TYPE_FLOAT);
}
/* G_TYPE_DOUBLE
*/
{
static const GTypeValueTable value_table = {
value_init_double, /* value_init */
NULL, /* value_free */
value_copy_double, /* value_copy */
NULL, /* value_peek_pointer */
"d", /* collect_format */
value_collect_double, /* collect_value */
"p", /* lcopy_format */
value_lcopy_double, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
g_assert (type == G_TYPE_DOUBLE);
}
/* G_TYPE_STRING
*/
{
static const GTypeValueTable value_table = {
value_init_string, /* value_init */
value_free_string, /* value_free */
value_copy_string, /* value_copy */
value_peek_pointer0, /* value_peek_pointer */
"p", /* collect_format */
value_collect_string, /* collect_value */
"p", /* lcopy_format */
value_lcopy_string, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
g_assert (type == G_TYPE_STRING);
}
/* G_TYPE_POINTER
*/
{
static const GTypeValueTable value_table = {
value_init_pointer, /* value_init */
NULL, /* value_free */
value_copy_pointer, /* value_copy */
value_peek_pointer0, /* value_peek_pointer */
"p", /* collect_format */
value_collect_pointer, /* collect_value */
"p", /* lcopy_format */
value_lcopy_pointer, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
g_assert (type == G_TYPE_POINTER);
}
/* G_TYPE_VARIANT
*/
{
static const GTypeValueTable value_table = {
value_init_pointer, /* value_init */
value_free_variant, /* value_free */
value_copy_variant, /* value_copy */
value_peek_pointer0, /* value_peek_pointer */
"p", /* collect_format */
value_collect_variant, /* collect_value */
"p", /* lcopy_format */
value_lcopy_variant, /* lcopy_value */
};
info.value_table = &value_table;
type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0);
g_assert (type == G_TYPE_VARIANT);
}
}
/* --- GValue functions --- */
/**
* g_value_set_char:
* @value: a valid #GValue of type %G_TYPE_CHAR
* @v_char: character value to be set
*
* Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
* Deprecated: 2.32: This function's input type is broken, see g_value_set_schar()
*/
void
g_value_set_char (GValue *value,
gchar v_char)
{
g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
value->data[0].v_int = v_char;
}
/**
* g_value_get_char:
* @value: a valid #GValue of type %G_TYPE_CHAR
*
* Do not use this function; it is broken on platforms where the %char
* type is unsigned, such as ARM and PowerPC. See g_value_get_schar().
*
* Get the contents of a %G_TYPE_CHAR #GValue.
*
* Returns: character contents of @value
* Deprecated: 2.32: This function's return type is broken, see g_value_get_schar()
*/
gchar
g_value_get_char (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
return value->data[0].v_int;
}
/**
* g_value_set_schar:
* @value: a valid #GValue of type %G_TYPE_CHAR
* @v_char: signed 8 bit integer to be set
*
* Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
*
* Since: 2.32
*/
void
g_value_set_schar (GValue *value,
gint8 v_char)
{
g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
value->data[0].v_int = v_char;
}
/**
* g_value_get_schar:
* @value: a valid #GValue of type %G_TYPE_CHAR
*
* Get the contents of a %G_TYPE_CHAR #GValue.
*
* Returns: signed 8 bit integer contents of @value
* Since: 2.32
*/
gint8
g_value_get_schar (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
return value->data[0].v_int;
}
/**
* g_value_set_uchar:
* @value: a valid #GValue of type %G_TYPE_UCHAR
* @v_uchar: unsigned character value to be set
*
* Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
*/
void
g_value_set_uchar (GValue *value,
guchar v_uchar)
{
g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
value->data[0].v_uint = v_uchar;
}
/**
* g_value_get_uchar:
* @value: a valid #GValue of type %G_TYPE_UCHAR
*
* Get the contents of a %G_TYPE_UCHAR #GValue.
*
* Returns: unsigned character contents of @value
*/
guchar
g_value_get_uchar (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
return value->data[0].v_uint;
}
/**
* g_value_set_boolean:
* @value: a valid #GValue of type %G_TYPE_BOOLEAN
* @v_boolean: boolean value to be set
*
* Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
*/
void
g_value_set_boolean (GValue *value,
gboolean v_boolean)
{
g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
value->data[0].v_int = v_boolean != FALSE;
}
/**
* g_value_get_boolean:
* @value: a valid #GValue of type %G_TYPE_BOOLEAN
*
* Get the contents of a %G_TYPE_BOOLEAN #GValue.
*
* Returns: boolean contents of @value
*/
gboolean
g_value_get_boolean (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
return value->data[0].v_int;
}
/**
* g_value_set_int:
* @value: a valid #GValue of type %G_TYPE_INT
* @v_int: integer value to be set
*
* Set the contents of a %G_TYPE_INT #GValue to @v_int.
*/
void
g_value_set_int (GValue *value,
gint v_int)
{
g_return_if_fail (G_VALUE_HOLDS_INT (value));
value->data[0].v_int = v_int;
}
/**
* g_value_get_int:
* @value: a valid #GValue of type %G_TYPE_INT
*
* Get the contents of a %G_TYPE_INT #GValue.
*
* Returns: integer contents of @value
*/
gint
g_value_get_int (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
return value->data[0].v_int;
}
/**
* g_value_set_uint:
* @value: a valid #GValue of type %G_TYPE_UINT
* @v_uint: unsigned integer value to be set
*
* Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
*/
void
g_value_set_uint (GValue *value,
guint v_uint)
{
g_return_if_fail (G_VALUE_HOLDS_UINT (value));
value->data[0].v_uint = v_uint;
}
/**
* g_value_get_uint:
* @value: a valid #GValue of type %G_TYPE_UINT
*
* Get the contents of a %G_TYPE_UINT #GValue.
*
* Returns: unsigned integer contents of @value
*/
guint
g_value_get_uint (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
return value->data[0].v_uint;
}
/**
* g_value_set_long:
* @value: a valid #GValue of type %G_TYPE_LONG
* @v_long: long integer value to be set
*
* Set the contents of a %G_TYPE_LONG #GValue to @v_long.
*/
void
g_value_set_long (GValue *value,
glong v_long)
{
g_return_if_fail (G_VALUE_HOLDS_LONG (value));
value->data[0].v_long = v_long;
}
/**
* g_value_get_long:
* @value: a valid #GValue of type %G_TYPE_LONG
*
* Get the contents of a %G_TYPE_LONG #GValue.
*
* Returns: long integer contents of @value
*/
glong
g_value_get_long (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
return value->data[0].v_long;
}
/**
* g_value_set_ulong:
* @value: a valid #GValue of type %G_TYPE_ULONG
* @v_ulong: unsigned long integer value to be set
*
* Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
*/
void
g_value_set_ulong (GValue *value,
gulong v_ulong)
{
g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
value->data[0].v_ulong = v_ulong;
}
/**
* g_value_get_ulong:
* @value: a valid #GValue of type %G_TYPE_ULONG
*
* Get the contents of a %G_TYPE_ULONG #GValue.
*
* Returns: unsigned long integer contents of @value
*/
gulong
g_value_get_ulong (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
return value->data[0].v_ulong;
}
/**
* g_value_get_int64:
* @value: a valid #GValue of type %G_TYPE_INT64
*
* Get the contents of a %G_TYPE_INT64 #GValue.
*
* Returns: 64bit integer contents of @value
*/
void
g_value_set_int64 (GValue *value,
gint64 v_int64)
{
g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
value->data[0].v_int64 = v_int64;
}
/**
* g_value_set_int64:
* @value: a valid #GValue of type %G_TYPE_INT64
* @v_int64: 64bit integer value to be set
*
* Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
*/
gint64
g_value_get_int64 (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
return value->data[0].v_int64;
}
/**
* g_value_set_uint64:
* @value: a valid #GValue of type %G_TYPE_UINT64
* @v_uint64: unsigned 64bit integer value to be set
*
* Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
*/
void
g_value_set_uint64 (GValue *value,
guint64 v_uint64)
{
g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
value->data[0].v_uint64 = v_uint64;
}
/**
* g_value_get_uint64:
* @value: a valid #GValue of type %G_TYPE_UINT64
*
* Get the contents of a %G_TYPE_UINT64 #GValue.
*
* Returns: unsigned 64bit integer contents of @value
*/
guint64
g_value_get_uint64 (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
return value->data[0].v_uint64;
}
/**
* g_value_set_float:
* @value: a valid #GValue of type %G_TYPE_FLOAT
* @v_float: float value to be set
*
* Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
*/
void
g_value_set_float (GValue *value,
gfloat v_float)
{
g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
value->data[0].v_float = v_float;
}
/**
* g_value_get_float:
* @value: a valid #GValue of type %G_TYPE_FLOAT
*
* Get the contents of a %G_TYPE_FLOAT #GValue.
*
* Returns: float contents of @value
*/
gfloat
g_value_get_float (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
return value->data[0].v_float;
}
/**
* g_value_set_double:
* @value: a valid #GValue of type %G_TYPE_DOUBLE
* @v_double: double value to be set
*
* Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
*/
void
g_value_set_double (GValue *value,
gdouble v_double)
{
g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
value->data[0].v_double = v_double;
}
/**
* g_value_get_double:
* @value: a valid #GValue of type %G_TYPE_DOUBLE
*
* Get the contents of a %G_TYPE_DOUBLE #GValue.
*
* Returns: double contents of @value
*/
gdouble
g_value_get_double (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
return value->data[0].v_double;
}
/**
* g_value_set_string:
* @value: a valid #GValue of type %G_TYPE_STRING
* @v_string: (allow-none): caller-owned string to be duplicated for the #GValue
*
* Set the contents of a %G_TYPE_STRING #GValue to @v_string.
*/
void
g_value_set_string (GValue *value,
const gchar *v_string)
{
gchar *new_val;
g_return_if_fail (G_VALUE_HOLDS_STRING (value));
new_val = g_strdup (v_string);
if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
value->data[1].v_uint = 0;
else
g_free (value->data[0].v_pointer);
value->data[0].v_pointer = new_val;
}
/**
* g_value_set_static_string:
* @value: a valid #GValue of type %G_TYPE_STRING
* @v_string: (allow-none): static string to be set
*
* Set the contents of a %G_TYPE_STRING #GValue to @v_string.
* The string is assumed to be static, and is thus not duplicated
* when setting the #GValue.
*/
void
g_value_set_static_string (GValue *value,
const gchar *v_string)
{
g_return_if_fail (G_VALUE_HOLDS_STRING (value));
if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
g_free (value->data[0].v_pointer);
value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
value->data[0].v_pointer = (gchar*) v_string;
}
/**
* g_value_set_string_take_ownership:
* @value: a valid #GValue of type %G_TYPE_STRING
* @v_string: (allow-none): duplicated unowned string to be set
*
* This is an internal function introduced mainly for C marshallers.
*
* Deprecated: 2.4: Use g_value_take_string() instead.
*/
void
g_value_set_string_take_ownership (GValue *value,
gchar *v_string)
{
g_value_take_string (value, v_string);
}
/**
* g_value_take_string:
* @value: a valid #GValue of type %G_TYPE_STRING
* @v_string: (allow-none): string to take ownership of
*
* Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
*
* Since: 2.4
*/
void
g_value_take_string (GValue *value,
gchar *v_string)
{
g_return_if_fail (G_VALUE_HOLDS_STRING (value));
if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
value->data[1].v_uint = 0;
else
g_free (value->data[0].v_pointer);
value->data[0].v_pointer = v_string;
}
/**
* g_value_get_string:
* @value: a valid #GValue of type %G_TYPE_STRING
*
* Get the contents of a %G_TYPE_STRING #GValue.
*
* Returns: string content of @value
*/
const gchar*
g_value_get_string (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
return value->data[0].v_pointer;
}
/**
* g_value_dup_string:
* @value: a valid #GValue of type %G_TYPE_STRING
*
* Get a copy the contents of a %G_TYPE_STRING #GValue.
*
* Returns: a newly allocated copy of the string content of @value
*/
gchar*
g_value_dup_string (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
return g_strdup (value->data[0].v_pointer);
}
/**
* g_value_set_pointer:
* @value: a valid #GValue of %G_TYPE_POINTER
* @v_pointer: pointer value to be set
*
* Set the contents of a pointer #GValue to @v_pointer.
*/
void
g_value_set_pointer (GValue *value,
gpointer v_pointer)
{
g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
value->data[0].v_pointer = v_pointer;
}
/**
* g_value_get_pointer:
* @value: a valid #GValue of %G_TYPE_POINTER
*
* Get the contents of a pointer #GValue.
*
* Returns: (transfer none): pointer contents of @value
*/
gpointer
g_value_get_pointer (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
return value->data[0].v_pointer;
}
G_DEFINE_POINTER_TYPE (GType, g_gtype)
/**
* g_value_set_gtype:
* @value: a valid #GValue of type %G_TYPE_GTYPE
* @v_gtype: #GType to be set
*
* Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
*
* Since: 2.12
*/
void
g_value_set_gtype (GValue *value,
GType v_gtype)
{
g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
value->data[0].v_pointer = GSIZE_TO_POINTER (v_gtype);
}
/**
* g_value_get_gtype:
* @value: a valid #GValue of type %G_TYPE_GTYPE
*
* Get the contents of a %G_TYPE_GTYPE #GValue.
*
* Since: 2.12
*
* Returns: the #GType stored in @value
*/
GType
g_value_get_gtype (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
return GPOINTER_TO_SIZE (value->data[0].v_pointer);
}
/**
* g_value_set_variant:
* @value: a valid #GValue of type %G_TYPE_VARIANT
* @variant: (allow-none): a #GVariant, or %NULL
*
* Set the contents of a variant #GValue to @variant.
* If the variant is floating, it is consumed.
*
* Since: 2.26
*/
void
g_value_set_variant (GValue *value,
GVariant *variant)
{
GVariant *old_variant;
g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
old_variant = value->data[0].v_pointer;
if (variant)
value->data[0].v_pointer = g_variant_ref_sink (variant);
else
value->data[0].v_pointer = NULL;
if (old_variant)
g_variant_unref (old_variant);
}
/**
* g_value_take_variant:
* @value: a valid #GValue of type %G_TYPE_VARIANT
* @variant: (allow-none): a #GVariant, or %NULL
*
* Set the contents of a variant #GValue to @variant, and takes over
* the ownership of the caller's reference to @variant;
* the caller doesn't have to unref it any more (i.e. the reference
* count of the variant is not increased).
*
* If @variant was floating then its floating reference is converted to
* a hard reference.
*
* If you want the #GValue to hold its own reference to @variant, use
* g_value_set_variant() instead.
*
* This is an internal function introduced mainly for C marshallers.
*
* Since: 2.26
*/
void
g_value_take_variant (GValue *value,
GVariant *variant)
{
GVariant *old_variant;
g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
old_variant = value->data[0].v_pointer;
if (variant)
value->data[0].v_pointer = g_variant_take_ref (variant);
else
value->data[0].v_pointer = NULL;
if (old_variant)
g_variant_unref (old_variant);
}
/**
* g_value_get_variant:
* @value: a valid #GValue of type %G_TYPE_VARIANT
*
* Get the contents of a variant #GValue.
*
* Returns: variant contents of @value
*
* Since: 2.26
*/
GVariant*
g_value_get_variant (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
return value->data[0].v_pointer;
}
/**
* g_value_dup_variant:
* @value: a valid #GValue of type %G_TYPE_VARIANT
*
* Get the contents of a variant #GValue, increasing its refcount.
*
* Returns: variant contents of @value, should be unrefed using
* g_variant_unref() when no longer needed
*
* Since: 2.26
*/
GVariant*
g_value_dup_variant (const GValue *value)
{
GVariant *variant;
g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
variant = value->data[0].v_pointer;
if (variant)
g_variant_ref_sink (variant);
return variant;
}
/**
* g_strdup_value_contents:
* @value: #GValue which contents are to be described.
*
* Return a newly allocated string, which describes the contents of a
* #GValue. The main purpose of this function is to describe #GValue
* contents for debugging output, the way in which the contents are
* described may change between different GLib versions.
*
* Returns: Newly allocated string.
*/
gchar*
g_strdup_value_contents (const GValue *value)
{
const gchar *src;
gchar *contents;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
if (G_VALUE_HOLDS_STRING (value))
{
src = g_value_get_string (value);
if (!src)
contents = g_strdup ("NULL");
else
{
gchar *s = g_strescape (src, NULL);
contents = g_strdup_printf ("\"%s\"", s);
g_free (s);
}
}
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
{
GValue tmp_value = G_VALUE_INIT;
gchar *s;
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_transform (value, &tmp_value);
s = g_strescape (g_value_get_string (&tmp_value), NULL);
g_value_unset (&tmp_value);
if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
contents = g_strdup_printf ("((%s) %s)",
g_type_name (G_VALUE_TYPE (value)),
s);
else
contents = g_strdup (s ? s : "NULL");
g_free (s);
}
else if (g_value_fits_pointer (value))
{
gpointer p = g_value_peek_pointer (value);
if (!p)
contents = g_strdup ("NULL");
else if (G_VALUE_HOLDS_OBJECT (value))
contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS_PARAM (value))
contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
GStrv strv = g_value_get_boxed (value);
GString *tmp = g_string_new ("[");
while (*strv != NULL)
{
gchar *escaped = g_strescape (*strv, NULL);
g_string_append_printf (tmp, "\"%s\"", escaped);
g_free (escaped);
if (*++strv != NULL)
g_string_append (tmp, ", ");
}
g_string_append (tmp, "]");
contents = g_string_free (tmp, FALSE);
}
else if (G_VALUE_HOLDS_BOXED (value))
contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
else if (G_VALUE_HOLDS_POINTER (value))
contents = g_strdup_printf ("((gpointer) %p)", p);
else
contents = g_strdup ("???");
}
else
contents = g_strdup ("???");
return contents;
}
/**
* g_pointer_type_register_static:
* @name: the name of the new pointer type.
*
* Creates a new %G_TYPE_POINTER derived type id for a new
* pointer type with name @name.
*
* Returns: a new %G_TYPE_POINTER derived type id for @name.
*/
GType
g_pointer_type_register_static (const gchar *name)
{
const GTypeInfo type_info = {
0, /* class_size */
NULL, /* base_init */
NULL, /* base_finalize */
NULL, /* class_init */
NULL, /* class_finalize */
NULL, /* class_data */
0, /* instance_size */
0, /* n_preallocs */
NULL, /* instance_init */
NULL /* value_table */
};
GType type;
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (g_type_from_name (name) == 0, 0);
type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
return type;
}
Reference in New Issue View Git Blame Copy Permalink