自学教程：C++ G_VALUE_TYPE函数代码示例

static gbooleangst_base_video_decoder_sink_setcaps (GstPad * pad, GstCaps * caps){  GstBaseVideoDecoder *base_video_decoder;  GstBaseVideoDecoderClass *base_video_decoder_class;  GstStructure *structure;  const GValue *codec_data;  GstVideoState *state;  gboolean ret = TRUE;  base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad));  base_video_decoder_class =      GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder);  GST_DEBUG ("setcaps %" GST_PTR_FORMAT, caps);  state = &base_video_decoder->state;  gst_base_video_decoder_reset_state (state);  structure = gst_caps_get_structure (caps, 0);  gst_video_format_parse_caps (caps, NULL, &state->width, &state->height);  gst_video_parse_caps_framerate (caps, &state->fps_n, &state->fps_d);  gst_video_parse_caps_pixel_aspect_ratio (caps, &state->par_n, &state->par_d);  gst_structure_get_boolean (structure, "interlaced", &state->interlaced);  codec_data = gst_structure_get_value (structure, "codec_data");  if (codec_data && G_VALUE_TYPE (codec_data) == GST_TYPE_BUFFER)    state->codec_data = gst_value_get_buffer (codec_data);  if (base_video_decoder_class->set_sink_caps)    ret = base_video_decoder_class->set_sink_caps (base_video_decoder, caps);  g_object_unref (base_video_decoder);  return ret;}

void _owr_deep_notify(GObject *object, GstObject *orig,    GParamSpec *pspec, gpointer user_data){    GValue value = G_VALUE_INIT;    gchar *str = NULL;    GstObject *it;    gchar *prevpath, *path;    OWR_UNUSED(user_data);    OWR_UNUSED(object);    path = g_strdup("");    for (it = orig; GST_IS_OBJECT(it); it = GST_OBJECT_PARENT(it)) {        prevpath = path;        path = g_strjoin("/", GST_OBJECT_NAME(it), prevpath, NULL);        g_free(prevpath);    }    if (pspec->flags & G_PARAM_READABLE) {        g_value_init(&value, pspec->value_type);        g_object_get_property(G_OBJECT(orig), pspec->name, &value);        if (G_VALUE_TYPE(&value) == GST_TYPE_CAPS)            str = gst_caps_to_string(gst_value_get_caps(&value));        else if (G_VALUE_HOLDS_STRING(&value))            str = g_value_dup_string(&value);        else            str = gst_value_serialize(&value);        GST_INFO_OBJECT(object, "%s%s = %s/n", path, pspec->name, str);        g_free(str);        g_value_unset(&value);    } else        GST_INFO_OBJECT(object, "Parameter %s not readable in %s.", pspec->name, path);    g_free(path);}

voidconting_attributes_get_valist(ContingAttributes *self,        const gchar *first, va_list ap){    g_return_if_fail(self != NULL && CONTING_IS_ATTRIBUTES(self));    while (first) {        gpointer *pointer;        const GValue *value;        pointer = va_arg(ap, gpointer *);        value = conting_attributes_get_value(self, first);        if (value == NULL) {            *pointer = NULL;        } else {            switch (G_VALUE_TYPE(value)) {				case G_TYPE_INT:					*((gint *) pointer) = g_value_get_int(value);					break;				case G_TYPE_DOUBLE:					*((gdouble *) pointer) = g_value_get_double(value);					break;				case G_TYPE_STRING:					*((const gchar **) pointer) = g_value_get_string(value);					break;				case G_TYPE_POINTER:				default:					*pointer = g_value_get_pointer(value);					break;			}        }        first = va_arg(ap, const gchar *);    }}

static voidenum_flags_format_cell_data (GtkCellLayout * cell_layout,                             GtkCellRenderer * cell,                             GtkTreeModel * tree_model,                             GtkTreeIter * iter, gpointer data){  gint colnum =      GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));  GValue value = { 0, };  gchar *string;  gtk_tree_model_get_value (tree_model, iter, NUM_COLUMNS + colnum, &value);  string = glade_utils_string_from_value (&value);  g_object_set (cell, "text", string && string[0] ?                glade_get_displayable_value (G_VALUE_TYPE (&value),                                             string) : "", NULL);  g_free (string);  g_value_unset (&value);}

static gchar *g_value_to_string (const GValue * val){  gchar *ret = NULL;  if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) {    GstBuffer *buf = gst_value_get_buffer (val);    GstMapInfo map;    gst_buffer_map (buf, &map, GST_MAP_READ);    ret = g_base64_encode (map.data, map.size);    gst_buffer_unmap (buf, &map);  } else {    GValue s = { 0, };    g_value_init (&s, G_TYPE_STRING);    if (g_value_transform (val, &s)) {      ret = g_value_dup_string (&s);      g_value_unset (&s);    }  }  return ret;}

gboolean audacious_dbus_string(DBusGProxy *proxy, const char *method, int pos, const char *arg, char* dest){	GValue val;	memset(&val, 0, sizeof(GValue));	GError *error = 0;	if (!dbus_g_proxy_call_with_timeout(proxy, method, DBUS_TIMEOUT, &error,				G_TYPE_UINT, pos,				G_TYPE_STRING, arg,				G_TYPE_INVALID,				G_TYPE_VALUE, &val,				G_TYPE_INVALID))	{		trace("Failed to make dbus call %s: %s", method, error->message);		return FALSE;	}	if (G_VALUE_TYPE(&val) == G_TYPE_STRING) {		strncpy(dest, g_value_get_string(&val), STRLEN);		dest[STRLEN-1] = 0;	}	g_value_unset(&val);	return TRUE;}

/** * g_value_array_insert: * @value_array: #GValueArray to add an element to * @index_: insertion position, must be <= value_array->;n_values * @value: (allow-none): #GValue to copy into #GValueArray, or %NULL * * Insert a copy of @value at specified position into @value_array. If @value * is %NULL, an uninitialized value is inserted. * * Returns: (transfer none): the #GValueArray passed in as @value_array * * Deprecated: 2.32: Use #GArray and g_array_insert_val() instead. */GValueArray*g_value_array_insert (GValueArray  *value_array,		      guint         index,		      const GValue *value){  guint i;  g_return_val_if_fail (value_array != NULL, NULL);  g_return_val_if_fail (index <= value_array->n_values, value_array);  i = value_array->n_values;  value_array_grow (value_array, value_array->n_values + 1, FALSE);  if (index + 1 < value_array->n_values)    memmove (value_array->values + index + 1, value_array->values + index,             (i - index) * sizeof (value_array->values[0]));  memset (value_array->values + index, 0, sizeof (value_array->values[0]));  if (value)    {      g_value_init (value_array->values + index, G_VALUE_TYPE (value));      g_value_copy (value, value_array->values + index);    }  return value_array;}

voidgsf_doc_prop_glue_get_val (GsfDocProp const *prop, GType *type, GValue *value) {	GValue const *prop_val;		if (prop == NULL)	  return;		prop_val = gsf_doc_prop_get_val (prop);		if (prop_val != NULL && G_IS_VALUE (prop_val)) {	  	  *type = G_VALUE_TYPE (prop_val);	  	  g_value_init (value, *type);	  g_value_copy (prop_val, value);	  	  /*	    printf ("Type == %d, G_TYPE_STRING=%d, G_VALUE_TYPE (prop_val)=%d/n", 	    *type, G_TYPE_STRING, G_VALUE_TYPE (prop_val));	    */  }    }

static gbooleanset_param_from_value (const TpCMParamSpec *paramspec,                      GValue *value,                      const TpCMParamSetter set_param,                      void *params,                      GError **error){  if (G_VALUE_TYPE (value) != paramspec->gtype)    {      DEBUG ("expected type %s for parameter %s, got %s",               g_type_name (paramspec->gtype), paramspec->name,               G_VALUE_TYPE_NAME (value));      g_set_error (error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT,          "expected type %s for account parameter %s, got %s",          g_type_name (paramspec->gtype), paramspec->name,          G_VALUE_TYPE_NAME (value));      return FALSE;    }  set_param (paramspec, value, params);  return TRUE;}

GValue *backend_command_get_key_value(const gchar * key, GValue * value){    gchar cmdBuf[COMMAND_BUFFER_SIZE];    gchar *cKey = mkdg_backend_get_key(backend, NULL, key, NULL);#ifdef USE_GSETTINGS    g_snprintf(cmdBuf, COMMAND_BUFFER_SIZE, "gsettings get %s %s",	       QUOTE_ME(PROJECT_SCHEMA_ID), cKey);#else    g_snprintf(cmdBuf, COMMAND_BUFFER_SIZE, "gconftool-2 --get  %s/%s",	       QUOTE_ME(PROJECT_GCONF2_SCHEMA_DIR), cKey);#endif    gchar *retStr = command_run_obtain_output(cmdBuf);#ifdef USE_GSETTINGS    /* gsettings prepend 'uint32 ' before actual value */    if (G_VALUE_TYPE(value) == G_TYPE_UINT) {	gint offset = strlen("uint32 ");	retStr += offset;    }#endif    mkdg_g_value_from_string(value, retStr);    return value;}

static gbooleanbuild_field_template (GQuark field_id, const GValue * value, gpointer user_data){  GString *s = (GString *) user_data;  const GstStructure *sub;  GValue template_value = { 0, };  GType type = G_TYPE_INVALID;  GstTracerValueFlags flags = GST_TRACER_VALUE_FLAGS_NONE;  gboolean res;  if (G_VALUE_TYPE (value) != GST_TYPE_STRUCTURE) {    GST_WARNING ("expected field of type GstStructure, but %s is %s",        g_quark_to_string (field_id), G_VALUE_TYPE_NAME (value));    return FALSE;  }  sub = gst_value_get_structure (value);  gst_structure_get (sub, "type", G_TYPE_GTYPE, &type, "flags",      GST_TYPE_TRACER_VALUE_FLAGS, &flags, NULL);  if (flags & GST_TRACER_VALUE_FLAGS_OPTIONAL) {    gchar *opt_name = g_strconcat ("have-", g_quark_to_string (field_id), NULL);    /* add a boolean field, that indicates the presence of the next field */    g_value_init (&template_value, G_TYPE_BOOLEAN);    priv__gst_structure_append_template_to_gstring (g_quark_from_string        (opt_name), &template_value, s);    g_value_unset (&template_value);    g_free (opt_name);  }  g_value_init (&template_value, type);  res = priv__gst_structure_append_template_to_gstring (field_id,      &template_value, s);  g_value_unset (&template_value);  return res;}

static void __set_expression_value (GValue *dest, GValue *src){	gchar *str;	switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (src))) {			case G_TYPE_STRING:			  str = g_strdup_printf ("'%s'", g_value_get_string (src));			  break;		case G_TYPE_UINT:			  str = g_strdup_printf ("%d", g_value_get_uint (src));			  break;		case G_TYPE_INT:			  str = g_strdup_printf ("%d", g_value_get_int (src));			  break;		case G_TYPE_FLOAT:			  str = g_strdup_printf ("%.04f", g_value_get_float (src));			  break;		case G_TYPE_BOOLEAN:			  str = g_strdup_printf ("%d", g_value_get_boolean (src));			  break;		case G_TYPE_BOXED:			  g_print ("BOXED type not implemented /n");			  break;		default:			  break;	}	g_value_take_string (dest, str);}

int main (int argc, char *argv[]){  GskXmlProcessor *xml_processor;  GskXmlConfig *config;  GValue value = { 0 };  int i;  gsk_init_without_threads (&argc, &argv);  config = gsk_xml_config_new (NULL);  g_return_val_if_fail (config, -1);  gsk_xml_config_add_type_test (config, return_true, NULL, NULL);  gsk_xml_config_set_loader (config, gsk_xml_loader_introspective, NULL, NULL);  xml_processor =    gsk_xml_processor_new (config, G_TYPE_OBJECT, handle_value, &value, NULL);  g_return_val_if_fail (xml_processor, -1);  for (i = 0; i < G_N_ELEMENTS (tests); ++i)    {      TestObject *object;      char *xml;      if (!gsk_xml_processor_input (xml_processor, tests[i], strlen (tests[i])))	g_error ("error parsing XML '%s'", tests[i]);      g_return_val_if_fail (G_VALUE_TYPE (&value) == G_TYPE_OBJECT, -1);      g_return_val_if_fail (TEST_IS_OBJECT (g_value_get_object (&value)), -1);      object = TEST_OBJECT (g_value_get_object (&value));      xml = test_object_get_xml (object);      g_return_val_if_fail (strcmp (xml, tests[i]) == 0, -1);      g_free (xml);      g_value_unset (&value);    }  gsk_xml_processor_destroy (xml_processor);  gsk_xml_config_unref (config);  return 0;}

void moto_variation_save_param(MotoVariation *self, MotoParam *p){    MotoVariationPriv *priv = MOTO_VARIATION_GET_PRIVATE(self);    GValue none = {0,};    guint id = moto_param_get_id(p);    GValue *pv = moto_param_get_value(p);    GType pt = G_VALUE_TYPE(pv);    GHashTable *params = priv->params;    GValue *v = (GValue *)g_hash_table_lookup(params, &id);    if( ! v)    {        v = g_slice_new(GValue);        *v = none;        g_value_init(v, pt);        guint *key = g_slice_new(guint);        *key = id;        g_hash_table_insert(params, key, v);    }    else if(g_type_is_a(pt, G_TYPE_OBJECT))    {        GObject *o = g_value_get_object(v);        if(o)            g_object_weak_unref(o, (GWeakNotify)null_value, v);    }    if(g_type_is_a(pt, G_TYPE_OBJECT))    {        GObject *o = moto_param_get_object(p);        if(o)            g_object_weak_ref(o, (GWeakNotify)null_value, v);    }    g_value_copy(pv, v);}

static GdaRow *create_new_row (GdaDataAccessWrapper *model){	gint i;	GdaRow *row;	row = gda_row_new (model->priv->nb_cols);	for (i = 0; i < model->priv->nb_cols; i++) {		GdaHolder *holder;		GValue *dest;		dest = gda_row_get_value (row, i);		if (model->priv->rows_mapping)			holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, model->priv->rows_mapping [i]);		else			holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, i);		if (holder) {			const GValue *cvalue = gda_holder_get_value (holder);			if (cvalue) {				gda_value_reset_with_type (dest, G_VALUE_TYPE ((GValue *) cvalue));				g_value_copy (cvalue, dest);			}			else				gda_value_set_null (dest);		}		else			gda_row_invalidate_value (row, dest);	}	gint *ptr;	ptr = g_new (gint, 1);	*ptr = model->priv->iter_row;	g_hash_table_insert (model->priv->rows, ptr, row);	/*g_print ("%s(%d)/n", __FUNCTION__, model->priv->iter_row);*/	return row;}

gboolean my_foreach_func(GQuark field_id, const GValue *value, gpointer user_data){	my_foreach_state &state = *((my_foreach_state *)user_data);	QString name = QString::fromLatin1(g_quark_to_string(field_id));	if(G_VALUE_TYPE(value) == G_TYPE_STRING && state.whitelist->contains(name))	{		QString svalue = QString::fromLatin1(g_value_get_string(value));		// FIXME: is there a better way to detect when we should do this conversion?		if(name == "configuration" && (state.out->name == "THEORA" || state.out->name == "VORBIS"))		{			QByteArray config = QByteArray::fromBase64(svalue.toLatin1());			svalue = hexEncode(config);		}		PPayloadInfo::Parameter i;		i.name = name;		i.value = svalue;		state.list->append(i);	}	return TRUE;}

static gchar *g_value_to_string (const GValue * val){  if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) {    const GstBuffer *buf = gst_value_get_buffer (val);    gchar *ret = g_base64_encode (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));    return ret;  } else {    GValue s = { 0, };    gchar *ret;    g_value_init (&s, G_TYPE_STRING);    if (!g_value_transform (val, &s)) {      return NULL;    }    ret = g_value_dup_string (&s);    g_value_unset (&s);    return ret;  }}

/** * cryptui_key_store_check_toggled: * @ckstore: a libcryptui key store * @view: a GtkTreeView * @iter: a GtkTreeIter * * Gets whether the check at iter is toggled */voidcryptui_key_store_check_toggled (CryptUIKeyStore *ckstore, GtkTreeView *view, GtkTreeIter *iter){    GtkTreeSelection *selection;    gboolean prev = FALSE;    GtkTreeIter base;    GValue v;    memset (&v, 0, sizeof(v));    g_return_if_fail (iter != NULL);    /* We get notified in filtered coordinates, we have to convert those to base */    key_store_get_base_iter (ckstore, iter, &base);    gtk_tree_model_get_value (GTK_TREE_MODEL (ckstore->priv->store), &base, CRYPTUI_KEY_STORE_CHECK, &v);    if(G_VALUE_TYPE (&v) == G_TYPE_BOOLEAN)        prev = g_value_get_boolean (&v);    g_value_unset (&v);    gtk_tree_store_set (GTK_TREE_STORE (ckstore->priv->store), &base, CRYPTUI_KEY_STORE_CHECK, prev ? FALSE : TRUE, -1);    selection = gtk_tree_view_get_selection (view);    g_signal_emit_by_name (selection, "changed");}

static gbooleanct_text_set_tooltip (DonnaColumnType    *ct,                     gpointer            _data,                     guint               index,                     DonnaNode          *node,                     GtkTooltip         *tooltip){    struct tv_col_data *data = _data;    DonnaNodeHasValue has;    GValue value = G_VALUE_INIT;    const gchar *s;    donna_node_get (node, FALSE,            (data->property_tooltip) ? data->property_tooltip : data->property,            &has, &value, NULL);    if (has != DONNA_NODE_VALUE_SET)        return FALSE;    if (G_VALUE_TYPE (&value) != G_TYPE_STRING)    {        g_value_unset (&value);        return FALSE;    }    /* don't show tooltip w/ an empty string */    s = g_value_get_string (&value);    if (s)    {        skip_blank (s);        if (*s != '/0')            gtk_tooltip_set_text (tooltip, g_value_get_string (&value));        else            s = NULL;    }    g_value_unset (&value);    return !!s;}

JNIEXPORT jlong JNICALLJava_org_gnome_glib_GValue_g_1value_1get_1pixbuf(    JNIEnv* env,    jclass cls,    jlong _value){    GValue* value;    GdkPixbuf* pixbuf;     // translate value    value = (GValue*) _value;    if (G_VALUE_TYPE(value) != GDK_TYPE_PIXBUF) {        bindings_java_throw(env, "You've asked for the GdkPixbuf within a GValue, but it's not a GDK_TYPE_PIXBUF!");        return 0L;    }    // call function    pixbuf = g_value_get_object(value);     // and return       return (jlong) pixbuf;}

static HaskellObj#ifdef GHC_RTS_USES_CAPABILITYgtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) {#elsegtk2hs_value_as_haskellobj(const GValue *value) {#endif    switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {    case G_TYPE_INTERFACE:        if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))            return rts_mkPtr(CAP g_value_get_object(value));        else            break;    case G_TYPE_CHAR:        return rts_mkChar(CAP g_value_get_schar(value));    case G_TYPE_UCHAR:        return rts_mkChar(CAP g_value_get_uchar(value));    case G_TYPE_BOOLEAN:        return rts_mkBool(CAP g_value_get_boolean(value));    case G_TYPE_INT:        return rts_mkInt(CAP g_value_get_int(value));    case G_TYPE_UINT:        return rts_mkWord(CAP g_value_get_uint(value));    case G_TYPE_LONG:        return rts_mkInt(CAP g_value_get_long(value));    case G_TYPE_ULONG:        return rts_mkWord(CAP g_value_get_ulong(value));    /*    case G_TYPE_INT64:            return rts_mkInt64(CAP g_value_get_int64(value));        case G_TYPE_UINT64:            return rts_mkWord64(CAP g_value_get_uint64(value));   */    case G_TYPE_ENUM:        return rts_mkInt(CAP g_value_get_enum(value));    case G_TYPE_FLAGS:        return rts_mkWord(CAP g_value_get_enum(value));    case G_TYPE_FLOAT:        return rts_mkFloat(CAP g_value_get_float(value));    case G_TYPE_DOUBLE:        return rts_mkDouble(CAP g_value_get_double(value));    case G_TYPE_STRING:        return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */    case G_TYPE_POINTER:        return rts_mkPtr(CAP g_value_get_pointer(value));    case G_TYPE_BOXED:        return rts_mkPtr(CAP g_value_get_boxed(value));    case G_TYPE_PARAM:        return rts_mkPtr(CAP g_value_get_param(value));    case G_TYPE_OBJECT:        return rts_mkPtr(CAP g_value_get_object(value));    }    g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s/n"            "please report this as a bug to [email
C++ G_VARIANT_TYPE函数代码示例
C++ G_VALUE_HOLDS_BOOLEAN函数代码示例