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

static gintxmms_browse_list_sortfunc (xmmsv_t **a, xmmsv_t **b){	xmmsv_t *val1, *val2;	const gchar *s1, *s2;	int r1, r2;	g_return_val_if_fail (xmmsv_is_type (*a, XMMSV_TYPE_DICT), 0);	g_return_val_if_fail (xmmsv_is_type (*b, XMMSV_TYPE_DICT), 0);	r1 = xmmsv_dict_get (*a, "intsort", &val1);	r2 = xmmsv_dict_get (*b, "intsort", &val2);	if (r1 && r2) {		gint i1, i2;		if (!xmmsv_get_int (val1, &i1))			return 0;		if (!xmmsv_get_int (val2, &i2))			return 0;		return i1 > i2;	}	if (!xmmsv_dict_get (*a, "path", &val1))		return 0;	if (!xmmsv_dict_get (*b, "path", &val2))		return 0;	if (!xmmsv_get_string (val1, &s1))		return 0;	if (!xmmsv_get_string (val2, &s2))		return 0;	return xmms_natcmp (s1, s2);}

static void__int_xmms_cmd_set_property_int (xmms_object_t *object, xmms_object_cmd_arg_t *arg){	xmmsv_t *t;	if (xmmsv_list_get_size (arg->args) != 4) {		XMMS_DBG ("Wrong number of arguments to set_property_int (%d)", xmmsv_list_get_size (arg->args));		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to set_property_int");		return;	}	gint32 argval0;	const char * argval1;	const char * argval2;	gint32 argval3;	if (!xmmsv_list_get (arg->args, 0, &t)) {		XMMS_DBG ("Missing arg 0 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in set_property_int");		return;	}	if (!xmmsv_get_int (t, &argval0)) {		XMMS_DBG ("Error parsing arg 0 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in set_property_int");		return;	}	if (!xmmsv_list_get (arg->args, 1, &t)) {		XMMS_DBG ("Missing arg 1 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 1 in set_property_int");		return;	}	if (!xmmsv_get_string (t, &argval1)) {		XMMS_DBG ("Error parsing arg 1 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 1 in set_property_int");		return;	}	if (!xmmsv_list_get (arg->args, 2, &t)) {		XMMS_DBG ("Missing arg 2 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 2 in set_property_int");		return;	}	if (!xmmsv_get_string (t, &argval2)) {		XMMS_DBG ("Error parsing arg 2 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 2 in set_property_int");		return;	}	if (!xmmsv_list_get (arg->args, 3, &t)) {		XMMS_DBG ("Missing arg 3 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 3 in set_property_int");		return;	}	if (!xmmsv_get_int (t, &argval3)) {		XMMS_DBG ("Error parsing arg 3 in set_property_int");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 3 in set_property_int");		return;	}	xmms_medialib_client_set_property_int ((xmms_medialib_t *) object, argval0, argval1, argval2, argval3, &arg->error);	arg->retval = xmmsv_new_none ();}

static void__int_xmms_cmd_rehash (xmms_object_t *object, xmms_object_cmd_arg_t *arg){	xmmsv_t *t;	if (xmmsv_list_get_size (arg->args) != 1) {		XMMS_DBG ("Wrong number of arguments to rehash (%d)", xmmsv_list_get_size (arg->args));		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to rehash");		return;	}	gint32 argval0;	if (!xmmsv_list_get (arg->args, 0, &t)) {		XMMS_DBG ("Missing arg 0 in rehash");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in rehash");		return;	}	if (!xmmsv_get_int (t, &argval0)) {		XMMS_DBG ("Error parsing arg 0 in rehash");		xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in rehash");		return;	}	xmms_medialib_client_rehash ((xmms_medialib_t *) object, argval0, &arg->error);	arg->retval = xmmsv_new_none ();}

static gintrefresh_active_playlist (xmmsv_t *val, void *udata){	cli_cache_t *cache = (cli_cache_t *) udata;	xmmsv_list_iter_t *it;	gint32 id;	if (!xmmsv_is_error (val)) {		/* Reset array */		if (cache->active_playlist->len > 0) {			gint len = cache->active_playlist->len;			cache->active_playlist = g_array_remove_range (cache->active_playlist,			                                               0, len);		}		xmmsv_get_list_iter (val, &it);		/* .. and refill it */		while (xmmsv_list_iter_valid (it)) {			xmmsv_t *entry;			xmmsv_list_iter_entry (it, &entry);			xmmsv_get_int (entry, &id);			g_array_append_val (cache->active_playlist, id);			xmmsv_list_iter_next (it);		}	}	freshness_received (&cache->freshness_active_playlist);	return TRUE;}

static voidxmms_ipc_register_broadcast (xmms_ipc_client_t *client,                             xmms_ipc_msg_t *msg, xmmsv_t *arguments){	xmmsv_t *arg;	gint32 broadcastid;	int r;	if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {		xmms_log_error ("No broadcastid in this msg?!");		return;	}	r = xmmsv_get_int (arg, &broadcastid);	if (!r) {		xmms_log_error ("Cannot extract broadcast id from value");		return;	}	if (broadcastid < 0 || broadcastid >= XMMS_IPC_SIGNAL_END) {		xmms_log_error ("Bad broadcast id (%d)", broadcastid);		return;	}	g_mutex_lock (client->lock);	client->broadcasts[broadcastid] =		g_list_append (client->broadcasts[broadcastid],				GUINT_TO_POINTER (xmms_ipc_msg_get_cookie (msg)));	g_mutex_unlock (client->lock);}

voidprint_hash (const gchar *key, xmmsv_t *value, void *udata){	xmmsv_type_t value_type;	const char *string_val;	unsigned int uint_val;	int int_val;	value_type = xmmsv_get_type (value);	switch (value_type) {		case XMMSV_TYPE_STRING:			xmmsv_get_string (value, &string_val);			print_info ("%s = %s", key, string_val);			break;		case XMMSV_TYPE_INT32:			xmmsv_get_int (value, &int_val);			print_info ("%s = %d", key, int_val);			break;		default:			print_error ("unhandled hash value %i", value_type);	}}

static voidxmms_ipc_register_signal (xmms_ipc_client_t *client,                          xmms_ipc_msg_t *msg, xmmsv_t *arguments){	xmmsv_t *arg;	gint32 signalid;	int r;	if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {		xmms_log_error ("No signalid in this msg?!");		return;	}	r = xmmsv_get_int (arg, &signalid);	if (!r) {		xmms_log_error ("Cannot extract signal id from value");		return;	}	if (signalid < 0 || signalid >= XMMS_IPC_SIGNAL_END) {		xmms_log_error ("Bad signal id (%d)", signalid);		return;	}	g_mutex_lock (client->lock);	client->pendingsignals[signalid] = xmms_ipc_msg_get_cookie (msg);	g_mutex_unlock (client->lock);}

static voidcurrently_playing_update_status (currently_playing_t *entry, xmmsv_t *value){	const gchar *status_name;	gint status = -1;	xmmsv_get_int (value, &status);	switch (status) {		case XMMS_PLAYBACK_STATUS_STOP:			status_name = _("Stopped");			break;		case XMMS_PLAYBACK_STATUS_PLAY:			status_name = _("Playing");			break;		case XMMS_PLAYBACK_STATUS_PAUSE:			status_name = _("Paused");			break;		default:			status_name = _("Unknown");			break;	}	xmmsv_dict_set_string (entry->data, "playback_status", status_name);}

static intupdater_rehash_file_by_id (xmmsv_t *value, void *udata){	xmmsc_result_t *res;	updater_t *updater;	int mid;	updater = (updater_t *) udata;	g_return_val_if_fail (updater, FALSE);	if (!xmmsv_get_int (value, &mid)) {		return FALSE;	}	if (!mid) {		g_warning ("Couldn't find requested medialib entry.");		return FALSE;	}	res = xmmsc_medialib_rehash (updater->conn, mid);	xmmsc_result_unref (res);	return FALSE;}

/**  * Convenient function for adding a directory to the playlist,  * It will dive down the URL you feed it and recursivly add  * all files there.  *  * @param playlist the playlist to add it URL to.  * @param plname the name of the playlist to modify.  * @param nurl the URL of an directory you want to add  * @param err an #xmms_error_t that should be defined upon error.  */static voidxmms_playlist_client_radd (xmms_playlist_t *playlist, const gchar *plname,                           const gchar *path, xmms_error_t *err){	xmmsv_coll_t *idlist;	xmmsv_list_iter_t *it;	xmmsv_t *list;	idlist = xmms_medialib_add_recursive (playlist->medialib, path, err);	list = xmmsv_coll_idlist_get (idlist);	xmmsv_get_list_iter (list, &it);	while (xmmsv_list_iter_valid (it)) {		xmms_medialib_entry_t entry;		xmmsv_t *value;		xmmsv_list_iter_entry (it, &value);		xmmsv_get_int (value, &entry);		xmms_playlist_add_entry (playlist, plname, entry, err);		xmmsv_list_iter_next (it);	}	xmmsv_coll_unref (idlist);}

/* dumps a recursive key-source-val dict */voidprint_entry (const gchar *key, xmmsv_t *dict, void *udata){	xmmsv_t *v;	const gchar *source;	if (xmmsv_get_type (dict) == XMMSV_TYPE_DICT) {		xmmsv_dict_iter_t *it;		xmmsv_get_dict_iter (dict, &it);		while (xmmsv_dict_iter_valid (it)) {			xmmsv_dict_iter_pair (it, &source, &v);			switch (xmmsv_get_type (v)) {			case XMMSV_TYPE_STRING:				print_entry_string (v, key, source);				break;			case XMMSV_TYPE_INT32:			{				gint i;				xmmsv_get_int (v, &i);				print_info ("[%s] %s = %d", source, key, i);				break;			}			default:				print_info ("[%s] %s = (unknown data)", source, key);				break;			}			xmmsv_dict_iter_next (it);		}	}}

static intupdater_remove_file_by_id (xmmsv_t *value, void *udata){	xmmsc_result_t *res;	updater_t *updater;	int mid;	updater = (updater_t *) udata;	g_return_val_if_fail (updater, FALSE);	if (!xmmsv_get_int (value, &mid)) {		g_error ("couldn't find this one!");		return FALSE;	}	if (!mid) {		g_debug ("entry not in medialib");		return FALSE;	}	res = xmmsc_medialib_remove_entry (updater->conn, mid);	xmmsc_result_unref (res);	return FALSE;}

static voidprint_config_entry (const gchar *confname, xmmsv_t *val, void *udata){	xmmsv_type_t type;	type = xmmsv_get_type (val);	switch (type) {	case XMMSV_TYPE_STRING:	{		const gchar *confval;		xmmsv_get_string (val, &confval);		g_printf ("%s = %s/n", confname, confval);		break;	}	case XMMSV_TYPE_INT32:	{		int confval;		xmmsv_get_int (val, &confval);		g_printf ("%s = %d/n", confname, confval);		break;	}	default:		break;	}}

static voidxmms_playlist_client_insert_collection (xmms_playlist_t *playlist, const gchar *plname,                                        gint32 pos, xmmsv_coll_t *coll,                                        xmmsv_t *order, xmms_error_t *err){	xmmsv_list_iter_t *it;	xmmsv_t *list;	list = xmms_collection_query_ids (playlist->colldag, coll, 0, 0, order, err);	if (xmms_error_iserror (err)) {		return;	}	xmmsv_get_list_iter (list, &it);	xmmsv_list_iter_last (it);	while (xmmsv_list_iter_valid (it)) {		xmms_medialib_entry_t mid;		xmmsv_t *entry;		xmmsv_list_iter_entry (it, &entry);		xmmsv_get_int (entry, &mid);		xmms_playlist_insert_entry (playlist, plname, pos, mid, err);		xmmsv_list_iter_prev (it);	}	xmmsv_unref (list);}

static voidadd_metadatum (gpointer _key, gpointer _value, gpointer user_data){	xmmsv_t *value = (xmmsv_t *) _value;	gchar *key = (gchar *) _key;	metadata_festate_t *st = (metadata_festate_t *) user_data;	if (xmmsv_get_type (value) == XMMSV_TYPE_STRING) {		const gchar *s;		xmmsv_get_string (value, &s);		xmms_medialib_entry_property_set_str_source (st->session,		                                             st->entry,		                                             key,		                                             s,		                                             st->source);	} else if (xmmsv_get_type (value) == XMMSV_TYPE_INT32) {		gint i;		xmmsv_get_int (value, &i);		xmms_medialib_entry_property_set_int_source (st->session,		                                             st->entry,		                                             key,		                                             i,		                                             st->source);	} else {		XMMS_DBG ("Unknown type?!?");	}}

boolsetup_udp_handle (xmmsc_result_t *res){	bool ret;	xmmsc_vis_udp_t *t;	xmmsc_visualization_t *visc;	visc = xmmsc_result_visc_get (res);	if (!visc) {		x_api_error_if (1, "non vis result?", -1);	}	t = &visc->transport.udp;	if (!xmmsc_result_iserror (res)) {		xmmsv_t *val;		int port;		val = xmmsc_result_get_value (res);		xmmsv_get_int (val, &port);		ret = setup_socket (xmmsc_result_get_connection (res), t, visc->id, port);	} else {		ret = false;	}	return ret;}

boolsetup_shm_handle (xmmsc_result_t *res){	bool ret;	xmmsc_visualization_t *visc;	xmmsc_vis_unixshm_t *t;	visc = xmmsc_result_visc_get (res);	if (!visc) {		x_api_error_if (1, "non vis result?", -1);	}	t = &visc->transport.shm;	if (!xmmsc_result_iserror (res)) {		xmmsv_t *val;		t->size = XMMS_VISPACKET_SHMCOUNT;		t->pos = 0;		val = xmmsc_result_get_value (res);		xmmsv_get_int (val, &t->semid);		ret = true;	} else {		/* didn't work, detach from shm to get it removed later on */		shmdt (t->buffer);		ret = false;	}	/* In either case, mark the shared memory segment to be destroyed.	   The segment will only actually be destroyed after the last process detaches it. */	shmctl (t->shmid, IPC_RMID, NULL);	return ret;}

static voidgetValue( Dict::Variant& val, xmmsv_t *value ){    switch( xmmsv_get_type( value ) ) {    case XMMSV_TYPE_INT32: {        int32_t temp = 0;        if( !xmmsv_get_int( value, &temp ) ) {            // FIXME: handle error        }        val = temp;        break;    }    case XMMSV_TYPE_STRING: {        const char* temp = 0;        if( !xmmsv_get_string( value, &temp ) ) {            // FIXME: handle error        }        val = std::string( temp );        break;    }    case XMMSV_TYPE_NONE: {        break;    }    default: {    }    }}

static int32_tol_player_xmms2_get_currend_id (){  /* ol_log_func (); */  if (!ol_player_xmms2_ensure_connection ())    return 0;  int32_t ret = 0;  xmmsc_result_t *result = xmmsc_playback_current_id (connection);  xmmsc_result_wait (result);  xmmsv_t *return_value = xmmsc_result_get_value (result);  if (xmmsv_is_error (return_value))  {    ol_error ("Error on getting current id");    ret = 0;  }  else  {    if (!xmmsv_get_int (return_value, &ret))    {      ol_error ("Get id from result failed");      ret = 0;    }  }  xmmsc_result_unref (result);  return ret;}

static intxmmsv_dict_get_int (xmmsv_t *dict,                    const char *key,                    int32_t *val){  xmmsv_t *dict_entry;  return (xmmsv_dict_get (dict, key, &dict_entry) &&          xmmsv_get_int (dict_entry, val));}

static VALUEint_get (xmmsv_t *val){	int32_t id = 0;	if (!xmmsv_get_int (val, &id))		rb_raise (eValueError, "cannot retrieve value");	return INT2NUM (id);}

/* Dumps a propdict on stdout */static voiddict_dump (const gchar *source, xmmsv_t *val, void *udata){	xmmsv_type_t type;	const gchar **keyfilter = (const gchar **) udata;	const gchar *key = (const gchar *) keyfilter[0];	const gchar *filter = (const gchar *) keyfilter[1];	if (filter && strcmp (filter, source) != 0) {		return;	}	type = xmmsv_get_type (val);	switch (type) {	case XMMSV_TYPE_INT32:	{		gint value;		xmmsv_get_int (val, &value);		g_printf (_("[%s] %s = %u/n"), source, key, value);		break;	}	case XMMSV_TYPE_STRING:	{		const gchar *value;		xmmsv_get_string (val, &value);		/* FIXME: special handling for url, guess charset, see common.c:print_entry */		g_printf (_("[%s] %s = %s/n"), source, key, value);		break;	}	case XMMSV_TYPE_LIST:		g_printf (_("[%s] %s = <list>/n"), source, key);		break;	case XMMSV_TYPE_DICT:		g_printf (_("[%s] %s = <dict>/n"), source, key);		break;	case XMMSV_TYPE_COLL:		g_printf (_("[%s] %s = <coll>/n"), source, key);		break;	case XMMSV_TYPE_BIN:		g_printf (_("[%s] %s = <bin>/n"), source, key);		break;	case XMMSV_TYPE_END:		g_printf (_("[%s] %s = <end>/n"), source, key);		break;	case XMMSV_TYPE_NONE:		g_printf (_("[%s] %s = <none>/n"), source, key);		break;	case XMMSV_TYPE_ERROR:		g_printf (_("[%s] %s = <error>/n"), source, key);		break;	}}

/* * We set this up as a callback for our current_id * method. Read the main program first before * returning here. */intmy_current_id (xmmsv_t *value, void *userdata){	/*	 * At this point the value struct contains the	 * answer. And we can now extract it as normal.	 */	int id;	int keep_alive = TRUE;	/*	 * we passed the udata struct as an argument	 * to set_notifier, which means it will be	 * passed as userdata to this function	 */	udata_t *udata = (udata_t *) userdata;	/*	 * Increase the counter that keeps track of how many	 * times we've visited the broadcast callback.	 */	udata->counter++;	if (!xmmsv_get_int (value, &id)) {		fprintf (stderr, "Value didn't contain the expected type!/n");		exit (EXIT_FAILURE);	}	printf ("Current id is %d/n", id);	/*	 * Check how many times the broadcast has been called.	 * If five times, then stop the broadcast and	 * tell the mainloop to exit.	 */	if (udata->counter == 5) {		printf ("Broadcast called %d times, exiting.../n", udata->counter);		g_main_loop_quit (udata->ml);		keep_alive = FALSE;	}	/*	 * As promised, let's explain this magic.  The return value of	 * callbacks has no purpose for normal commands, but in the case	 * of signals and broadcasts, it determines whether we want to keep	 * running that callback or not.	 * If returning TRUE, a signal would be restarted and a broadcast	 * would keep going.	 * If returning FALSE, a signal would not be restarted and a	 * broadcast would be disconnected, i.e. they would stop.	 * Here, we return FALSE after the callback is called 5 times.	 */	return keep_alive;}

static voidcurrently_playing_update_playtime (currently_playing_t *entry, xmmsv_t *value){	gchar *formatted;	gint playtime;	xmmsv_get_int (value, &playtime);	formatted = format_time (playtime, FALSE);	xmmsv_dict_set_string (entry->data, "playtime", formatted);	g_free (formatted);}

/* * We set this up as a callback for our current_id * method. Read the main program first before * returning here. */intmy_playtime (xmmsv_t *value, void *userdata){	/*	 * At this point the result struct is filled with the	 * answer. And we can now extract it as normal.	 */	int time;	int keep_alive;	/*	 * we passed the mainloop as an argument	 * to set_notifier, which means it will be	 * passed as userdata to this function	 */	GMainLoop *ml = (GMainLoop *) userdata;	if (!xmmsv_get_int (value, &time)) {		fprintf (stderr, "Value didn't contain the expected type!/n");		exit (EXIT_FAILURE);	}	/*	 * Print the time on the same line and flush stdout	 * so that the text becomes visible.	 */	printf ("/r%4dms has been played", time);	fflush (stdout);	/*	 * We will exit the application after 5000ms have passed.	 * Otherwise we will restart the signal to enable this	 * callback to be called yet another time.	 */	if (time > 5000) {		printf ("/nMore than 5000 ms has been played, exiting.../n");		g_main_loop_quit (ml);		keep_alive = FALSE;	} else {		/* Tell the server to send updates to the		 * same callback (AKA restart the signal) */		keep_alive = TRUE;	}	/*	 * We use the return value of the callback once	 * again to determine whether to restart the signal	 * or just let it die.	 */	return keep_alive;}

/** * Return a new value object which is a deep copy of the input value * * @param val #xmmsv_t to copy. * @return 1 the address to the new copy of the value. */xmmsv_t *xmmsv_copy (xmmsv_t *val){	xmmsv_t *cur_val = NULL;	xmmsv_type_t type;	int64_t i;	const char *s;	float f;	x_return_val_if_fail (val, 0);	type = xmmsv_get_type (val);	switch (type) {		case XMMSV_TYPE_DICT:			cur_val = duplicate_dict_value (val);			break;		case XMMSV_TYPE_LIST:			cur_val = duplicate_list_value (val);			break;		case XMMSV_TYPE_INT64:			xmmsv_get_int (val, &i);			cur_val = xmmsv_new_int (i);			break;		case XMMSV_TYPE_FLOAT:			xmmsv_get_float (val, &f);			cur_val = xmmsv_new_float (f);			break;		case XMMSV_TYPE_STRING:			xmmsv_get_string (val, &s);			cur_val = xmmsv_new_string (s);			break;		case XMMSV_TYPE_ERROR:			xmmsv_get_error (val, &s);			cur_val = xmmsv_new_error (s);			break;		case XMMSV_TYPE_COLL:			cur_val = duplicate_coll_value (val);			break;		case XMMSV_TYPE_BIN:			cur_val = xmmsv_new_bin (val->value.bin.data, val->value.bin.len);			break;		case XMMSV_TYPE_BITBUFFER:			cur_val = xmmsv_new_bitbuffer ();			xmmsv_bitbuffer_put_data (cur_val, val->value.bit.buf, val->value.bit.len / 8);			xmmsv_bitbuffer_goto (cur_val, xmmsv_bitbuffer_pos (val));			break;		default:			cur_val = xmmsv_new_none ();			break;	}	assert (cur_val);	return cur_val;}

static gintrefresh_playback_status (xmmsv_t *val, void *udata){	cli_cache_t *cache = (cli_cache_t *) udata;	if (!xmmsv_is_error (val)) {		xmmsv_get_int (val, &cache->playback_status);	}	freshness_received (&cache->freshness_playback_status);	return TRUE;}

static gintrefresh_currid (xmmsv_t *val, void *udata){	cli_cache_t *cache = (cli_cache_t *) udata;	if (!xmmsv_is_error (val)) {		xmmsv_get_int (val, &cache->currid);	}	freshness_received (&cache->freshness_currid);	return TRUE;}

gbooleanxmms_xform_auxdata_get_int (xmms_xform_t *xform, const gchar *key, gint32 *val){	const xmmsv_t *obj;	obj = xmms_xform_auxdata_get_val (xform, key);	if (obj && xmmsv_get_type (obj) == XMMSV_TYPE_INT32) {		xmmsv_get_int (obj, val);		return TRUE;	}	return FALSE;}

static gintxmms_browse_list_sortfunc (gconstpointer a, gconstpointer b){	int r1, r2;	xmmsv_t *val1, *val2, *tmp1, *tmp2;	const gchar *s1, *s2;	val1 = (xmmsv_t *) a;	val2 = (xmmsv_t *) b;	g_return_val_if_fail (xmmsv_get_type (val1) == XMMSV_TYPE_DICT, 0);	g_return_val_if_fail (xmmsv_get_type (val2) == XMMSV_TYPE_DICT, 0);	r1 = xmmsv_dict_get (val1, "intsort", &tmp1);	r2 = xmmsv_dict_get (val2, "intsort", &tmp2);	if (r1 && r2) {		gint i1, i2;		if (!xmmsv_get_int (tmp1, &i1))			return 0;		if (!xmmsv_get_int (tmp2, &i2))			return 0;		return i1 > i2;	}	if (!xmmsv_dict_get (val1, "path", &tmp1))		return 0;	if (!xmmsv_dict_get (val2, "path", &tmp2))		return 0;	if (!xmmsv_get_string (tmp1, &s1))		return 0;	if (!xmmsv_get_string (tmp2, &s2))		return 0;	return xmms_natcmp (s1, s2);}