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

gboolean dbus_glib_object1_struct_example_method_impl (DBusGlibObject1 *self, 		GValueArray*         st,                gint*		 ret,        GError **error){		GValue *val;    		val = g_value_array_get_nth(st, 0);	  	if (G_VALUE_HOLDS(val, G_TYPE_INT)) 		if (g_value_type_compatible (G_VALUE_TYPE (val), G_TYPE_INT))	    	if(g_value_get_int(val) != 1234)	              *ret = -1;	    		val = g_value_array_get_nth(st, 1);  	if (G_VALUE_HOLDS(val, G_TYPE_STRING))    	if (g_value_type_compatible (G_VALUE_TYPE (val), G_TYPE_STRING))    		if(strcmp("StructPassing", g_value_get_string(val)))    				*ret = -1;	    if(*ret != -1)    	*ret = 5050;    	return TRUE;}

static GList *parse_one_formats_list (GHashTable *sysinfo_dict,                                       const char *key){    GValue *to_parse;    GList *formats = NULL;    GValueArray *array;    gint i;    to_parse = g_hash_table_lookup (sysinfo_dict, key);    if (to_parse == NULL) {        return NULL;    }    if (!G_VALUE_HOLDS (to_parse, G_TYPE_VALUE_ARRAY)) {        return NULL;    }    array = (GValueArray*)g_value_get_boxed (to_parse);    for (i = 0; i < array->n_values; i++) {        Itdb_ArtworkFormat *format;	/* SysInfoExtended on the iPhone has <string> fields in the artwork	 * format array in addition to the hash we parse	 */	if (!G_VALUE_HOLDS (g_value_array_get_nth (array, i), G_TYPE_HASH_TABLE)) {	    continue;	}	format = g_value_to_image_format (g_value_array_get_nth (array, i));	if (format != NULL) {		formats = g_list_prepend (formats, format);	}    }     g_hash_table_remove (sysinfo_dict, key);    return formats;}

/** * fs_stream_parse_new_active_candidate_pair: * @stream: a #FsStream to match against the message * @message: a #GstMessage to parse * @local_candidate: (out) (transfer none): Returns the local #FsCandidate in *  the message if not %NULL. * @remote_candidate: (out) (transfer none): Returns the remote #FsCandidate in *  the message if not %NULL. * * Parses a "farstream-new-active-candidate-pair" message and checks * if it matches the @stream parameters. * * Returns: %TRUE if the message matches the stream and is valid. */gbooleanfs_stream_parse_new_active_candidate_pair (FsStream *stream,        GstMessage *message,        FsCandidate **local_candidate,        FsCandidate **remote_candidate){    const GstStructure *s;    const GValue *value;    g_return_val_if_fail (stream != NULL, FALSE);    if (!check_message (message, stream, "farstream-new-active-candidate-pair"))        return FALSE;    s = gst_message_get_structure (message);    value = gst_structure_get_value (s, "local-candidate");    if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE))        return FALSE;    if (local_candidate)        *local_candidate = g_value_get_boxed (value);    value = gst_structure_get_value (s, "remote-candidate");    if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE))        return FALSE;    if (remote_candidate)        *remote_candidate = g_value_get_boxed (value);    return TRUE;}

/** * fs_stream_parse_component_state_changed: * @stream: a #FsStream to match against the message * @message: a #GstMessage to parse * @component: (out): Returns the component from the #GstMessage if not %NULL * @state: (out): Returns the #FsStreamState from the #GstMessage if not %NULL * * Parses a "farstream-component-state-changed" message and checks if it matches * the @stream parameters. * * Returns: %TRUE if the message matches the stream and is valid. */gbooleanfs_stream_parse_component_state_changed (FsStream *stream,        GstMessage *message,        guint *component,        FsStreamState *state){    const GstStructure *s;    const GValue *value;    g_return_val_if_fail (stream != NULL, FALSE);    if (!check_message (message, stream, "farstream-component-state-changed"))        return FALSE;    s = gst_message_get_structure (message);    value = gst_structure_get_value (s, "component");    if (!value || !G_VALUE_HOLDS (value, G_TYPE_UINT))        return FALSE;    if (component)        *component = g_value_get_uint (value);    value = gst_structure_get_value (s, "state");    if (!value || !G_VALUE_HOLDS (value, G_TYPE_ENUM))        return FALSE;    if (state)        *state = g_value_get_enum (value);    return TRUE;}

static void midgard_timestamp_transform_from_gda_timestamp(const GValue *src, GValue *dst){	g_return_if_fail(G_VALUE_HOLDS(src, GDA_TYPE_TIMESTAMP) &&			G_VALUE_HOLDS(dst, MGD_TYPE_TIMESTAMP));	MidgardTimestamp *mt = midgard_timestamp_new();		GdaTimestamp *gt = (GdaTimestamp *) g_value_get_boxed(src);	mt->year = gt->year;	/* Avoid 0000 year */	if (mt->year == 0)		mt->year = 1;	mt->month = gt->month;	/* Avoid 00 month */	if (mt->month == 0)		mt->month = 1;	mt->day = gt->day;	/* Avoid 00 day */	if (mt->day == 0)		mt->day = 1;	mt->hour = gt->hour;	mt->minute = gt->minute;	mt->second = gt->second;	mt->offset = gt->timezone;	if (gt->timezone == GDA_TIMEZONE_INVALID)		mt->offset = 0;	g_value_take_boxed(dst, mt);	}

/** * fs_session_parse_send_codec_changed: * @session: a #FsSession to match against the message * @message: a #GstMessage to parse * @codec: (out) (transfer none): Returns the #FsCodec in the message if not *   %NULL. * @secondary_codecs: (out) (transfer none) (element-type FsCodec): *  Returns a #GList of #FsCodec of the message if not %NULL * * Parses a "farstream-send-codec-changed" message and checks if it matches * the @session parameters. * * Returns: %TRUE if the message matches the session and is valid. */gbooleanfs_session_parse_send_codec_changed ( FsSession *session,    GstMessage *message,    FsCodec **codec,    GList **secondary_codecs){  const GstStructure *s;  const GValue *value;  g_return_val_if_fail (session != NULL, FALSE);  if (!check_message (message, session, "farstream-send-codec-changed"))    return FALSE;  s = gst_message_get_structure (message);  value = gst_structure_get_value (s, "codec");  if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC))    return FALSE;  if (codec)    *codec = g_value_get_boxed (value);  value = gst_structure_get_value (s, "secondary-codecs");  if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC_LIST))    return FALSE;  if (secondary_codecs)    *secondary_codecs = g_value_get_boxed (value);  return TRUE;}

gchar *gda_postgres_render_CREATE_DB (GdaServerProvider *provider, GdaConnection *cnc, 			       GdaServerOperation *op, G_GNUC_UNUSED GError **error){	GString *string;	const GValue *value;	gchar *sql = NULL;	gchar *tmp;	string = g_string_new ("CREATE DATABASE ");	tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/DB_DEF_P/DB_NAME", error);	if (!tmp) {		g_string_free (string, TRUE);		return NULL;	}	g_string_append (string, tmp);	g_free (tmp);	value = gda_server_operation_get_value_at (op, "/DB_DEF_P/OWNER");	if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {		g_string_append (string, " OWNER ");		g_string_append (string, g_value_get_string (value));	}	value = gda_server_operation_get_value_at (op, "/DB_DEF_P/TEMPLATE");	if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {		g_string_append (string, " TEMPLATE ");		g_string_append (string, g_value_get_string (value));	}	value = gda_server_operation_get_value_at (op, "/DB_DEF_P/DB_CSET");	if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {		GdaDataHandler *dh;		gchar *str;				dh = gda_server_provider_get_data_handler_g_type (provider, cnc, G_TYPE_STRING);		str = gda_data_handler_get_sql_from_value (dh, value);		if (str) {			g_string_append (string, " ENCODING ");			g_string_append (string, str);			g_free (str);		}	}	value = gda_server_operation_get_value_at (op, "/DB_DEF_P/TABLESPACE");	if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {		g_string_append (string, " TABLESPACE ");		g_string_append (string, g_value_get_string (value));	}	sql = string->str;	g_string_free (string, FALSE);	return sql;	}

static gbooleanopus_dec_sink_setcaps (GstPad * pad, GstCaps * caps){  GstOpusDec *dec = GST_OPUS_DEC (gst_pad_get_parent (pad));  gboolean ret = TRUE;  GstStructure *s;  const GValue *streamheader;  s = gst_caps_get_structure (caps, 0);  if ((streamheader = gst_structure_get_value (s, "streamheader")) &&      G_VALUE_HOLDS (streamheader, GST_TYPE_ARRAY) &&      gst_value_array_get_size (streamheader) >= 2) {    const GValue *header;    GstBuffer *buf;    GstFlowReturn res = GST_FLOW_OK;    header = gst_value_array_get_value (streamheader, 0);    if (header && G_VALUE_HOLDS (header, GST_TYPE_BUFFER)) {      buf = gst_value_get_buffer (header);      res = opus_dec_chain_parse_header (dec, buf);      if (res != GST_FLOW_OK)        goto done;      gst_buffer_replace (&dec->streamheader, buf);    }#if 0    vorbiscomment = gst_value_array_get_value (streamheader, 1);    if (vorbiscomment && G_VALUE_HOLDS (vorbiscomment, GST_TYPE_BUFFER)) {      buf = gst_value_get_buffer (vorbiscomment);      res = opus_dec_chain_parse_comments (dec, buf);      if (res != GST_FLOW_OK)        goto done;      gst_buffer_replace (&dec->vorbiscomment, buf);    }#endif    g_list_foreach (dec->extra_headers, (GFunc) gst_mini_object_unref, NULL);    g_list_free (dec->extra_headers);    dec->extra_headers = NULL;    if (gst_value_array_get_size (streamheader) > 2) {      gint i, n;      n = gst_value_array_get_size (streamheader);      for (i = 2; i < n; i++) {        header = gst_value_array_get_value (streamheader, i);        buf = gst_value_get_buffer (header);        dec->extra_headers =            g_list_prepend (dec->extra_headers, gst_buffer_ref (buf));      }    }  }done:  gst_object_unref (dec);  return ret;}

static int_sort_by_index (ClutterModel *model,                const GValue *a,                const GValue *b,                gpointer user_data){    g_assert (G_VALUE_HOLDS (a, G_TYPE_UINT));    g_assert (G_VALUE_HOLDS (b, G_TYPE_UINT));    return g_value_get_uint (a) - g_value_get_uint (b);}

gchar *gda_postgres_render_DROP_INDEX   (GdaServerProvider *provider, GdaConnection *cnc, 				  GdaServerOperation *op, G_GNUC_UNUSED GError **error){	GString *string;	const GValue *value;	gchar *sql = NULL;	gchar *tmp;	string = g_string_new ("DROP INDEX ");	tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/INDEX_DESC_P/INDEX_NAME", error);	if (!tmp) {		g_string_free (string, TRUE);		return NULL;	}	g_string_append (string, tmp);	g_free (tmp);	value = gda_server_operation_get_value_at (op, "/INDEX_DESC_P/REFERENCED_ACTION");	if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {		g_string_append_c (string, ' ');		g_string_append (string, g_value_get_string (value));	}	sql = string->str;	g_string_free (string, FALSE);	return sql;}

static gbooleancheck_message (GstMessage *message,    FsSession *session,    const gchar *message_name){  const GstStructure *s;  const GValue *value;  FsSession *message_session;  if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)    return FALSE;  s = gst_message_get_structure (message);  if (!gst_structure_has_name (s, message_name))    return FALSE;  value = gst_structure_get_value (s, "session");  if (!value || !G_VALUE_HOLDS (value, FS_TYPE_SESSION))    return FALSE;  message_session = g_value_get_object (value);  if (session != message_session)    return FALSE;  return TRUE;}

static Itdb_ArtworkFormat *g_value_to_image_format (GValue *value){    GHashTable *dict;    Itdb_ArtworkFormat *img_spec;    g_return_val_if_fail (G_VALUE_HOLDS (value, G_TYPE_HASH_TABLE), NULL);    dict = g_value_get_boxed (value);    g_return_val_if_fail (dict != NULL, NULL);    img_spec = g_new0 (Itdb_ArtworkFormat, 1);    if (img_spec == NULL) {        return NULL;    }    if (!set_pixel_format (img_spec, dict)) {        g_free (img_spec);        return NULL;    }    set_back_color (img_spec, dict);    dict_to_struct (dict, sysinfo_image_format_fields_mapping, img_spec);    if (get_boolean (dict, "AlignRowBytes")            && (img_spec->row_bytes_alignment == 0)) {        /* at least the nano3g has the AlignRowBytes key with no         * RowBytesAlignment key.         */        img_spec->row_bytes_alignment = 4;    }    return img_spec;}

gchar *_gda_sqlite_render_DROP_VIEW (G_GNUC_UNUSED GdaServerProvider *provider, GdaConnection *cnc, 			     GdaServerOperation *op, G_GNUC_UNUSED GError **error){	GString *string;	const GValue *value;	gchar *sql = NULL;	gchar *tmp;	string = g_string_new ("DROP VIEW");	value = gda_server_operation_get_value_at (op, "/VIEW_DESC_P/VIEW_IFEXISTS");	if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))		g_string_append (string, " IF EXISTS");	tmp = gda_connection_operation_get_sql_identifier_at (cnc,  op, "/VIEW_DESC_P/VIEW_NAME", error);	if (!tmp) {		g_string_free (string, TRUE);		return NULL;	}	g_string_append_c (string, ' ');	g_string_append (string, tmp);	g_free (tmp);	sql = string->str;	g_string_free (string, FALSE);	return sql;}

static gbooleangdl_dock_reorder (GdlDockObject    *object,                  GdlDockObject    *requestor,                  GdlDockPlacement  new_position,                  GValue           *other_data){    GdlDock *dock = GDL_DOCK (object);    gboolean handled = FALSE;        if (dock->_priv->floating &&        new_position == GDL_DOCK_FLOATING &&        dock->root == requestor) {                if (other_data && G_VALUE_HOLDS (other_data, GDK_TYPE_RECTANGLE)) {            GdkRectangle *rect;            rect = g_value_get_boxed (other_data);            gtk_window_move (GTK_WINDOW (dock->_priv->window),                             rect->x,                             rect->y);            handled = TRUE;        }    }        return handled;}

gboolean_nm_ip6_address_array_demarshal (GValue *value, GSList **dest){	GPtrArray *array;	if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UCHAR))		return FALSE;	if (*dest) {		g_slist_foreach (*dest, (GFunc) g_free, NULL);		g_slist_free (*dest);		*dest = NULL;	}	array = (GPtrArray *) g_value_get_boxed (value);	if (array && array->len) {		int i;		for (i = 0; i < array->len; i++) {			GByteArray *bytearray = (GByteArray *) g_ptr_array_index (array, i);			struct in6_addr *addr;			addr = g_malloc0 (sizeof (struct in6_addr));			memcpy (addr->s6_addr, bytearray->data, bytearray->len);			*dest = g_slist_append (*dest, addr);		}	}	return TRUE;}

/** * fs_session_parse_telephony_event_started: * @session: a #FsSession to match against the message * @message: a #GstMessage to parse * @method: (out): Returns the #FsDTMFMethod in the message if not %NULL. * @event: (out): Returns the #FsDTMFEvent in the message if not %NULL. * @volume: (out): Returns the volume in the message if not %NULL. * * Parses a "farstream-telephony-event-started" message and checks if it matches * the @session parameters. * * Returns: %TRUE if the message matches the session and is valid. */gbooleanfs_session_parse_telephony_event_started (FsSession *session,    GstMessage *message,    FsDTMFMethod *method, FsDTMFEvent *event,    guint8 *volume){  const GstStructure *s;  const GValue *value;  g_return_val_if_fail (session != NULL, FALSE);  if (!check_message (message, session, "farstream-telephony-event-started"))    return FALSE;  s = gst_message_get_structure (message);  if (!gst_structure_has_field_typed (s, "method", FS_TYPE_DTMF_METHOD))    return FALSE;  if (method)    gst_structure_get_enum (s, "method", FS_TYPE_DTMF_METHOD, (gint*) method);  if (!gst_structure_has_field_typed (s, "event", FS_TYPE_DTMF_EVENT))    return FALSE;  if (event)    gst_structure_get_enum (s, "event", FS_TYPE_DTMF_EVENT, (gint*) event);  value = gst_structure_get_value (s, "volume");  if (!value || !G_VALUE_HOLDS (value, G_TYPE_UCHAR))    return FALSE;  if (volume)    *volume = g_value_get_uchar (value);  return TRUE;}

gchar *midgard_timestamp_dup_string(const GValue *value) {        g_assert(G_VALUE_HOLDS(value, MIDGARD_TYPE_TIMESTAMP));	MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed(value);        return (gchar *)caltime_fmt(mt); }

static voidart_cb (RBExtDBKey *key, const char *filename, GValue *data, MxFrame *frame){    ClutterActor *image;    GdkPixbuf *pixbuf;    if (data == NULL || G_VALUE_HOLDS (data, GDK_TYPE_PIXBUF) == FALSE) {        return;    }    clutter_threads_enter ();    image = gtk_clutter_texture_new ();    pixbuf = GDK_PIXBUF (g_value_get_object (data));    gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE (image), pixbuf, NULL);    if (clutter_actor_get_height (image) > MAX_IMAGE_HEIGHT) {        clutter_actor_set_height (image, MAX_IMAGE_HEIGHT);        clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (image), TRUE);    }    if (clutter_actor_get_width (image) > MAX_IMAGE_HEIGHT) {        clutter_actor_set_width (image, MAX_IMAGE_HEIGHT);    }    mx_bin_set_child (MX_BIN (frame), image);    clutter_actor_show_all (CLUTTER_ACTOR (frame));    clutter_threads_leave ();}

static GSList *add_domains (GSList *items,             GHashTable *hash,             const char *prefix,             const char four_or_six){	GValue *val;	char **domains = NULL;	GString *tmp;	guint i;	/* Search domains */	val = g_hash_table_lookup (hash, "domains");	if (!val)		return items;	g_return_val_if_fail (G_VALUE_HOLDS (val, G_TYPE_STRV), items);	domains = (char **) g_value_get_boxed (val);	if (!domains || !domains[0])		return items;	tmp = g_string_new (NULL);	g_string_append_printf (tmp, "%sIP%c_DOMAINS=", prefix, four_or_six);	for (i = 0; domains[i]; i++) {		if (i > 0)			g_string_append_c (tmp, ' ');		g_string_append (tmp, domains[i]);	}	items = g_slist_prepend (items, tmp->str);	g_string_free (tmp, FALSE);	return items;}

voidtmpl_iterator_init (TmplIterator *iter,                    const GValue *value){  memset (iter, 0, sizeof *iter);  if (value == NULL)    return;  if (G_VALUE_HOLDS_STRING (value))    {      iter->instance = (gchar *)g_value_get_string (value);      iter->move_next = string_move_next;      iter->get_value = string_get_value;      iter->destroy = NULL;    }  else if (G_VALUE_HOLDS (value, G_TYPE_LIST_MODEL))    {      iter->instance = g_value_get_object (value);      iter->move_next = list_model_move_next;      iter->get_value = list_model_get_value;      iter->destroy = NULL;    }  /* TODO: More iter types */}

static voidip4_dns_writer (GKeyFile *file,                NMSetting *setting,                const char *key,                const GValue *value){	GArray *array;	char **list;	int i, num = 0;	g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UINT_ARRAY));	array = (GArray *) g_value_get_boxed (value);	if (!array || !array->len)		return;	list = g_new0 (char *, array->len + 1);	for (i = 0; i < array->len; i++) {		char buf[INET_ADDRSTRLEN + 1];		struct in_addr addr;		addr.s_addr = g_array_index (array, guint32, i);		if (!inet_ntop (AF_INET, &addr, buf, sizeof (buf))) {			nm_warning ("%s: error converting IP4 address 0x%X",			            __func__, ntohl (addr.s_addr));		} else			list[num++] = g_strdup (buf);	}	g_key_file_set_string_list (file, nm_setting_get_name (setting), key, (const char **) list, num);	g_strfreev (list);}

static voidmac_address_writer (GKeyFile *file,                    NMSetting *setting,                    const char *key,                    const GValue *value){	GByteArray *array;	const char *setting_name = nm_setting_get_name (setting);	char *mac;	struct ether_addr tmp;	g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UCHAR_ARRAY));	array = (GByteArray *) g_value_get_boxed (value);	if (!array)		return;	if (array->len != ETH_ALEN) {		nm_warning ("%s: invalid %s / %s MAC address length %d",		            __func__, setting_name, key, array->len);		return;	}	memcpy (tmp.ether_addr_octet, array->data, ETH_ALEN);	mac = ether_ntoa (&tmp);	g_key_file_set_string (file, setting_name, key, mac);}

static gbooleancheck_message (GstMessage *message,               FsStream *stream,               const gchar *message_name){    const GstStructure *s;    const GValue *value;    FsStream *message_stream;    if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)        return FALSE;    s = gst_message_get_structure (message);    if (!gst_structure_has_name (s, message_name))        return FALSE;    value = gst_structure_get_value (s, "stream");    if (!value || !G_VALUE_HOLDS (value, FS_TYPE_STREAM))        return FALSE;    message_stream = g_value_get_object (value);    if (stream != message_stream)        return FALSE;    return TRUE;}

static gint_gvalues_compare_struct (const GValue *value1, const GValue *value2){	/* value1 and value2 must contain the same type since	 * _gvalues_compare() enforced that already.	 */	if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ADDRESS)) {		return nm_gvalue_ip6_address_compare (value1, value2);	} else if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ROUTE)) {		return nm_gvalue_ip6_route_compare (value1, value2);	} else {		g_warning ("Don't know how to compare structures");		return (value1 == value2);	}}

static voidset_property (GObject     * object,              guint         prop_id,              GValue const* value,              GParamSpec  * pspec){  switch (prop_id)    {    case PROP_WORKSPACE:      /* FIXME: update to renames */      g_return_if_fail (!PRIV (object)->workspace);      g_return_if_fail (g_value_get_object (value));      g_return_if_fail (G_VALUE_HOLDS (value, WNCK_TYPE_WORKSPACE));      PRIV (object)->workspace = g_value_get_object (value);      gtk_label_set_text (GTK_LABEL (PRIV (object)->label),                          wnck_workspace_get_name (PRIV (object)->workspace));      g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "active-window-changed",                        G_CALLBACK (active_window_changed), object);      g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "window-closed",                        G_CALLBACK (window_closed), object);      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;    }}

static gbooleanupdate_one_secret (NMSetting *setting, const char *key, GValue *value, GError **error){	gboolean success = FALSE;	g_return_val_if_fail (key != NULL, FALSE);	g_return_val_if_fail (value != NULL, FALSE);	if (G_VALUE_HOLDS_STRING (value)) {		/* Passing the string properties individually isn't correct, and won't		 * produce the correct result, but for some reason that's how it used		 * to be done.  So even though it's not correct, keep the code around		 * for compatibility's sake.		 */		success = update_secret_string (setting, key, g_value_get_string (value), error);	} else if (G_VALUE_HOLDS (value, DBUS_TYPE_G_MAP_OF_STRING)) {		if (strcmp (key, NM_SETTING_VPN_SECRETS) != 0) {			g_set_error (error, NM_SETTING_ERROR, NM_SETTING_ERROR_PROPERTY_NOT_SECRET,			             "Property %s not a secret property", key);		} else			success = update_secret_hash (setting, g_value_get_boxed (value), error);	} else		g_set_error_literal (error, NM_SETTING_ERROR, NM_SETTING_ERROR_PROPERTY_TYPE_MISMATCH, key);	if (success)		g_object_notify (G_OBJECT (setting), NM_SETTING_VPN_SECRETS);	return success;}

static voidartwork_notify_cb (RhythmDB *db,		   RhythmDBEntry *entry,		   const char *property_name,		   const GValue *metadata,		   RBMtpSource *source){	RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);	GdkPixbuf *pixbuf;	const char *album_name;	album_name = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM);	/* check if we're looking for art for this entry, and if we actually got some */	if (g_hash_table_remove (priv->artwork_request_map, album_name) == FALSE)		return;	if (G_VALUE_HOLDS (metadata, GDK_TYPE_PIXBUF) == FALSE)		return;	pixbuf = GDK_PIXBUF (g_value_get_object (metadata));	rb_mtp_thread_set_album_image (priv->device_thread, album_name, pixbuf);	queue_free_space_update (source);}

static gbooleanclutter_behaviour_path_parse_custom_node (ClutterScriptable *scriptable,                                          ClutterScript     *script,                                          GValue            *value,                                          const gchar       *name,                                          JsonNode          *node){  if (strcmp ("path", name) == 0)    {      ClutterPath *path;      GValue node_value = { 0 };      path = g_object_ref_sink (clutter_path_new ());      json_node_get_value (node, &node_value);      if (!G_VALUE_HOLDS (&node_value, G_TYPE_STRING)          || !clutter_path_set_description (path,                                            g_value_get_string (&node_value)))        g_warning ("Invalid path description");      g_value_unset (&node_value);      g_value_init (value, G_TYPE_OBJECT);      g_value_take_object (value, path);      return TRUE;    }  /* chain up */  else if (parent_scriptable_iface->parse_custom_node)    return parent_scriptable_iface->parse_custom_node (scriptable, script,                                                       value, name, node);  else    return FALSE;}

static PyObject *_wrap_value_array_get_nth_type(PyObject *self, PyObject *args){  guint n;  GType type;  GValue *nth;  GValueArray *arr;  PyObject *obj;  if (!PyArg_ParseTuple(args, "OI", &obj, &n))    return NULL;  G_GNUC_BEGIN_IGNORE_DEPRECATIONS  if (pyg_boxed_check(obj, G_TYPE_VALUE) &&      G_VALUE_HOLDS(pyg_boxed_get(obj, GValue), G_TYPE_VALUE_ARRAY)) {    arr = g_value_get_boxed(pyg_boxed_get(obj, GValue));  } else if (pyg_boxed_check(obj, G_TYPE_VALUE_ARRAY)) {    arr = pyg_boxed_get(obj, GValueArray);  } else {    PyErr_SetString(PyExc_TypeError, "First argument is not GValueArray");    return NULL;  }  if (n >= arr->n_values) {    PyErr_SetString(PyExc_TypeError, "Index is out of bounds");    return NULL;  }  nth = g_value_array_get_nth(arr, n);  type = G_VALUE_TYPE(nth);  G_GNUC_END_IGNORE_DEPRECATIONS  return pyg_type_wrapper_new(type);}

gchar *_gda_sqlite_render_CREATE_VIEW (G_GNUC_UNUSED GdaServerProvider *provider, GdaConnection *cnc, 			       GdaServerOperation *op, G_GNUC_UNUSED GError **error){	GString *string;	const GValue *value;	gboolean allok = TRUE;	gchar *sql = NULL;	gchar *tmp;	string = g_string_new ("CREATE ");	value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_TEMP");	if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))		g_string_append (string, "TEMP ");	g_string_append (string, "VIEW ");	value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_IFNOTEXISTS");	if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))		g_string_append (string, "IF NOT EXISTS ");	tmp = gda_connection_operation_get_sql_identifier_at (cnc,  op, "/VIEW_DEF_P/VIEW_NAME", error);	if (!tmp) {		g_string_free (string, TRUE);		return NULL;	}	g_string_append (string, tmp);	g_free (tmp);		if (allok) {		value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_DEF");		g_assert (value && G_VALUE_HOLDS (value, G_TYPE_STRING));		g_string_append (string, " AS ");		g_string_append (string, g_value_get_string (value));	}	if (allok) {		sql = string->str;		g_string_free (string, FALSE);	}	else {		sql = NULL;		g_string_free (string, TRUE);	}	return sql;}