static void
print_collections_list (xmmsc_result_t *res, cli_infos_t *infos,
gchar *mark, gboolean all)
{
const gchar *s, *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* Skip hidden playlists if all is FALSE*/
if (xmmsv_get_string (entry, &s) && ((*s != '_') || all)) {
/* Highlight active playlist */
if (mark && strcmp (s, mark) == 0) {
g_printf ("* %s\n", s);
} else {
g_printf (" %s\n", s);
}
}
xmmsv_list_iter_next (it);
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
static gboolean
run_tests (xmms_medialib_t *medialib, xmmsv_t *testcases, xmms_test_predicate predicate,
gint format, const gchar *datasetname)
{
xmmsv_list_iter_t *it;
xmmsv_t *dict;
gboolean result = TRUE;
xmmsv_get_list_iter (testcases, &it);
while (xmmsv_list_iter_entry (it, &dict)) {
xmmsv_t *content, *specification, *expected, *coll;
const gchar *name;
xmmsv_dict_entry_get_string (dict, "name", &name);
xmmsv_dict_get (dict, "medialib", &content);
xmmsv_dict_get (dict, "specification", &specification);
xmmsv_dict_get (dict, "collection", &coll);
xmmsv_dict_get (dict, "expected", &expected);
result &= predicate (medialib, name, content, coll, specification,
expected, format, datasetname);
xmmsv_list_iter_next (it);
}
return result;
}
static bool
_internal_put_on_bb_value_list (xmmsv_t *bb, xmmsv_t *v)
{
xmmsv_list_iter_t *it;
xmmsv_t *entry;
uint32_t offset, count;
bool ret = true;
if (!xmmsv_get_list_iter (v, &it)) {
return false;
}
/* store a dummy value, store the real count once it's known */
offset = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, 0);
count = 0;
while (xmmsv_list_iter_valid (it)) {
xmmsv_list_iter_entry (it, &entry);
ret = xmmsv_bitbuffer_serialize_value (bb, entry);
xmmsv_list_iter_next (it);
count++;
}
/* overwrite with real size */
xmmsv_bitbuffer_put_bits_at (bb, 32, count, offset);
return ret;
}
static gint
refresh_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;
}
/** List a playlist */
static GList *
xmms_playlist_client_list_entries (xmms_playlist_t *playlist, const gchar *plname,
xmms_error_t *err)
{
GList *entries = NULL;
xmmsv_coll_t *plcoll;
xmms_medialib_entry_t entry;
xmmsv_list_iter_t *it;
g_return_val_if_fail (playlist, NULL);
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
g_mutex_unlock (playlist->mutex);
return NULL;
}
xmmsv_get_list_iter (xmmsv_coll_idlist_get (plcoll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
entries = g_list_prepend (entries, xmmsv_new_int (entry));
}
xmmsv_list_iter_explicit_destroy (it);
g_mutex_unlock (playlist->mutex);
entries = g_list_reverse (entries);
return entries;
}
/**
* 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 void
xmms_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);
}
static void
query_string_append_fetch (coll_query_t *query, GString *qstring)
{
coll_query_alias_t *alias;
xmmsv_list_iter_t *it;
xmmsv_t *valstr;
gboolean first = TRUE;
const gchar *name;
for (xmmsv_get_list_iter (query->params->fetch, &it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
/* extract string from cmdval_t */
xmmsv_list_iter_entry (it, &valstr);
xmmsv_get_string (valstr, &name);
alias = query_make_alias (query, name, TRUE);
if (first) first = FALSE;
else {
g_string_append (qstring, ", ");
}
query_string_append_alias (qstring, alias,
COLL_QUERY_VALUE_TYPE_BOTH);
g_string_append_printf (qstring, " AS %s", name);
}
}
static int
handle_remove_from_mlib (xmmsv_t *v, void *userdata)
{
xmonitor_t *mon = userdata;
xmmsc_result_t *res2;
xmmsv_list_iter_t *it;
for (xmmsv_get_list_iter (v, &it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
guint32 id;
xmmsv_t *elem;
if (!xmmsv_list_iter_entry (it, &elem) || !xmmsv_get_uint (elem, &id)) {
ERR ("Failed to get entry id from hash!");
continue;
}
if (id == 0) {
DBG ("Entry not in db!");
continue;
}
DBG ("Removing %d", id);
res2 = xmmsc_medialib_remove_entry (mon->conn, id);
xmmsc_result_unref (res2);
}
return FALSE;
}
static void
run_tests (xmms_medialib_t *medialib, xmmsv_t *testcases, xmms_test_predicate predicate,
gint format, const gchar *datasetname)
{
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (testcases, &it);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *dict, *content, *specification, *holder, *expected;
xmmsv_coll_t *coll;
const gchar *name;
dict = NULL;
g_assert (xmmsv_list_iter_entry (it, &dict));
xmmsv_dict_entry_get_string (dict, "name", &name);
xmmsv_dict_get (dict, "medialib", &content);
xmmsv_dict_get (dict, "specification", &specification);
xmmsv_dict_get (dict, "collection", &holder);
xmmsv_dict_get (dict, "expected", &expected);
xmmsv_get_coll (holder, &coll);
predicate (medialib, name, content, coll, specification,
expected, format, datasetname);
xmmsv_list_iter_next (it);
}
}
void
list_plugins (cli_infos_t *infos, xmmsc_result_t *res)
{
const gchar *name, *desc, *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *elem;
xmmsv_list_iter_entry (it, &elem);
xmmsv_dict_entry_get_string (elem, "shortname", &name);
xmmsv_dict_entry_get_string (elem, "description", &desc);
g_printf ("%s - %s\n", name, desc);
}
} else {
g_printf (_("Server error: %s\n"), err);
}
xmmsc_result_unref (res);
cli_infos_loop_resume (infos);
}
static void
run_performance_tests (xmmsv_t *databases, xmmsv_t *testcases, gint format)
{
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (databases, &it);
while (xmmsv_list_iter_valid (it)) {
xmms_medialib_t *medialib;
const gchar *filename;
xmmsv_list_iter_entry_string (it, &filename);
if (format == FORMAT_PRETTY)
g_print ("Running suite with: %s\n", filename);
xmms_ipc_init ();
xmms_config_init ("memory://");
xmms_config_property_register ("medialib.path", filename, NULL, NULL);
medialib = xmms_medialib_init ();
if (medialib == NULL) {
g_print ("Could not open database: %s (%d)\n", filename, s4_errno ());
exit (EXIT_FAILURE);
}
run_tests (medialib, testcases, run_performance_test, format, filename);
xmms_object_unref (medialib);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
xmmsv_list_iter_next (it);
}
}
void
positions_print_list (xmmsc_result_t *res, playlist_positions_t *positions,
column_display_t *coldisp, gboolean is_search)
{
cli_infos_t *infos = column_display_infos_get (coldisp);
pl_pos_udata_t udata = { infos, coldisp, NULL, NULL, 0, 0};
xmmsv_t *val;
GArray *entries;
guint id;
const gchar *err;
/* FIXME: separate function or merge
with list_print_row (lot of if(positions))? */
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
column_display_prepare (coldisp);
if (is_search) {
column_display_print_header (coldisp);
}
entries = g_array_sized_new (FALSE, FALSE, sizeof (guint),
xmmsv_list_get_size (val));
for (xmmsv_get_list_iter (val, &it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
g_array_append_val (entries, id);
}
}
udata.entries = entries;
playlist_positions_foreach (positions, pos_print_row_cb, TRUE, &udata);
} else {
g_printf (_("Server error: %s\n"), err);
}
if (is_search) {
column_display_print_footer (coldisp);
} else {
g_printf ("\n");
column_display_print_footer_totaltime (coldisp);
}
column_display_free (coldisp);
g_array_free (entries, TRUE);
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
xmmsv_coll_t *
xmmsv_coll_copy (xmmsv_coll_t *orig_coll)
{
xmmsv_coll_t *new_coll, *coll_elem;
xmmsv_list_iter_t *it;
xmmsv_dict_iter_t *itd;
xmmsv_t *v, *list, *dict;
const char *key;
int32_t i;
const char *s;
new_coll = xmmsv_coll_new (xmmsv_coll_get_type (orig_coll));
list = xmmsv_coll_idlist_get (orig_coll);
x_return_val_if_fail (xmmsv_get_list_iter (list, &it), NULL);
while (xmmsv_list_iter_valid (it)) {
xmmsv_list_iter_entry (it, &v);
xmmsv_get_int (v, &i);
xmmsv_coll_idlist_append (new_coll, i);
xmmsv_list_iter_next (it);
}
xmmsv_list_iter_explicit_destroy (it);
list = xmmsv_coll_operands_get (orig_coll);
x_return_val_if_fail (xmmsv_get_list_iter (list, &it), NULL);
while (xmmsv_list_iter_valid (it)) {
xmmsv_list_iter_entry (it, &v);
xmmsv_get_coll (v, &coll_elem);
xmmsv_coll_add_operand (new_coll, xmmsv_coll_copy (coll_elem));
xmmsv_list_iter_next (it);
}
xmmsv_list_iter_explicit_destroy (it);
dict = xmmsv_coll_attributes_get (orig_coll);
x_return_val_if_fail (xmmsv_get_dict_iter (dict, &itd), NULL);
while (xmmsv_dict_iter_valid (itd)) {
xmmsv_dict_iter_pair (itd, &key, &v);
xmmsv_get_string (v, &s);
xmmsv_coll_attribute_set (new_coll, key, s);
xmmsv_dict_iter_next (itd);
}
xmmsv_dict_iter_explicit_destroy (itd);
return new_coll;
}
/* Given a list of fields, append the corresponding aliases to the argument string. */
static void
query_string_append_alias_list (coll_query_t *query, GString *qstring,
xmmsv_t *fields)
{
coll_query_alias_t *alias;
xmmsv_list_iter_t *it;
xmmsv_t *valstr;
gboolean first = TRUE;
for (xmmsv_get_list_iter (fields, &it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
/* extract string from cmdval_t */
const gchar *field, *canon_field;
xmmsv_list_iter_entry (it, &valstr);
xmmsv_get_string (valstr, &field);
canon_field = canonical_field_name (field);
if (first) first = FALSE;
else {
g_string_append (qstring, ", ");
}
if (canon_field != NULL) {
alias = query_get_alias (query, canon_field);
if (alias != NULL) {
query_string_append_alias (qstring, alias,
COLL_QUERY_VALUE_TYPE_BOTH);
} else {
if (*field != '~') {
if (strcmp(canon_field, "id") == 0) {
g_string_append (qstring, "m0.id");
} else {
g_string_append_printf (qstring,
"(SELECT IFNULL (intval, value) "
"FROM Media WHERE id = m0.id AND key='%s' AND "
"xmms_source_pref (source) = "
"(SELECT MIN (xmms_source_pref (n.source)) "
"FROM Media AS n WHERE n.id = m0.id AND "
"n.key = '%s'))",
canon_field, canon_field);
}
}
}
}
/* special prefix for ordering */
if (*field == '-') {
g_string_append (qstring, " DESC");
} else if (*field == '~') {
/* FIXME: Temporary hack to allow custom ordering functions */
g_string_append (qstring, field + 1);
}
}
}
static xmmsv_t *
normalize_metadata_fields (xmmsv_t *fetch, xmms_error_t *err)
{
gpointer SENTINEL = GINT_TO_POINTER (0x31337);
GHashTable *table;
xmmsv_list_iter_t *it;
xmmsv_t *fields;
if (!xmmsv_dict_get (fetch, "fields", &fields)) {
/* No fields means that we should fetch all fields */
return NULL;
}
if (xmmsv_get_type (fields) != XMMSV_TYPE_LIST) {
const gchar *message = "'fields' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
if (xmmsv_list_get_size (fields) < 1) {
/* No fields means that we should fetch all fields */
return NULL;
}
table = g_hash_table_new (g_str_hash, g_str_equal);
xmmsv_get_list_iter (fields, &it);
while (xmmsv_list_iter_valid (it)) {
const gchar *value = NULL;
if (!xmmsv_list_iter_entry_string (it, &value)) {
const gchar *message = "'fields' entries must be of string type.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_hash_table_unref (table);
return NULL;
}
if (g_hash_table_lookup (table, (gpointer) value) == SENTINEL) {
const gchar *message = "'fields' entries must be unique.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_hash_table_unref (table);
return NULL;
}
g_hash_table_insert (table, (gpointer) value, SENTINEL);
xmmsv_list_iter_next (it);
}
g_hash_table_unref (table);
return fields;
}
void plugin_config_setup (xmmsc_connection_t *con)
{
xmmsc_result_t* res;
xmmsv_t *val;
const gchar *err, *name;
/* call only once */
g_assert(plugins == NULL );
/* get translation of plugins/configs */
plugin_config_init_translation();
/* get list of available plugins */
res = xmmsc_main_list_plugins (con, XMMS_PLUGIN_TYPE_OUTPUT);
/* we havn't entered async xmmsc_mainloop, so it's ok todo sync ops */
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it))
{
xmmsv_t *elem;
Plugin *plugin;
xmmsv_list_iter_entry (it, &elem);
xmmsv_dict_entry_get_string (elem, "shortname", &name);
/* not blacklisted */
if ( g_strrstr( PLUGIN_BLACKLIST, name ) != NULL )
continue;
plugin = g_slice_new( Plugin );
plugin->name = g_strdup(name);
plugin->config = NULL;
plugins = g_list_append(plugins, plugin);
}
} else {
g_error ( "Server error: %s", err);
}
xmmsc_result_unref (res);
/* get configuration options */
res = xmmsc_config_list_values (con );
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach( val, plugin_config_setup_parameter, NULL);
}
static int
_xmmsv_coll_operand_find (xmmsv_list_iter_t *it, xmmsv_t *op)
{
xmmsv_t *v;
while (xmmsv_list_iter_entry (it, &v)) {
if (v == op) {
return 1;
}
xmmsv_list_iter_next (it);
}
return 0;
}
static int
updater_remove_directory_by_id (xmmsv_t *value, void *udata)
{
xmmsv_list_iter_t *it;
xmmsv_t *item;
xmmsv_get_list_iter (value, &it);
while (xmmsv_list_iter_entry (it, &item)) {
updater_remove_file_by_id (item, udata);
xmmsv_list_iter_next (it);
}
return TRUE;
}
void
remove_cached_list (xmmsc_result_t *matching, cli_infos_t *infos)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *rmres;
guint plid, id;
gint plsize;
GArray *playlist;
gint i;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (matching);
plsize = infos->cache->active_playlist->len;
playlist = infos->cache->active_playlist;
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
/* Loop on the playlist (backward, easier to remove) */
for (i = plsize - 1; i >= 0; i--) {
plid = g_array_index (playlist, guint, i);
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* If both match, remove! */
if (xmmsv_get_uint (entry, &id) && plid == id) {
rmres = xmmsc_playlist_remove_entry (infos->sync, NULL, i);
xmmsc_result_wait (rmres);
xmmsc_result_unref (rmres);
break;
}
}
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
}
static void
cli_info_print (xmmsv_t *propdict)
{
xmmsv_t *properties, *sourcedict, *sources, *value;
xmmsv_list_iter_t *pit, *sit;
const gchar *source, *property;
gint source_width;
GString *sb;
if (!xmmsv_propdict_lengths (propdict, NULL, &source_width)) {
return;
}
sb = g_string_sized_new (source_width);
xmmsv_dict_keys (propdict, &properties);
xmmsv_list_sort (properties, xmmsv_strcmp);
xmmsv_get_list_iter (properties, &pit);
while (xmmsv_list_iter_entry_string (pit, &property)) {
if (xmmsv_dict_get (propdict, property, &sourcedict)) {
xmmsv_dict_keys (sourcedict, &sources);
xmmsv_list_sort (sources, xmmsv_strcmp);
xmmsv_get_list_iter (sources, &sit);
while (xmmsv_list_iter_entry_string (sit, &source)) {
if (xmmsv_dict_get (sourcedict, source, &value)) {
cli_info_pad_source (sb, source_width, source);
xmmsv_print_value (sb->str, property, value);
}
xmmsv_list_iter_next (sit);
}
}
xmmsv_list_iter_next (pit);
}
g_string_free (sb, TRUE);
}
static void
parse_idlist (xmmsv_t *coll, xmmsv_t *list)
{
xmmsv_list_iter_t *it;
int32_t id;
assert (xmmsv_is_type (list, XMMSV_TYPE_LIST));
assert (xmmsv_get_list_iter (list, &it));
while (xmmsv_list_iter_entry_int (it, &id)) {
assert (xmmsv_coll_idlist_append (coll, id));
xmmsv_list_iter_next (it);
}
}
void
xmms_playlist_client_add_idlist (xmms_playlist_t *playlist,
const gchar *plname,
xmmsv_coll_t *coll, xmms_error_t *err)
{
xmms_medialib_entry_t entry;
xmmsv_list_iter_t *it;
gboolean valid;
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
MEDIALIB_SESSION (playlist->medialib,
valid = xmms_medialib_check_id (session, entry));
if (!valid) {
xmms_error_set (err, XMMS_ERROR_NOENT,
"Idlist contains invalid medialib id!");
xmmsv_list_iter_explicit_destroy (it);
return;
}
}
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
xmms_playlist_add_entry (playlist, plname, entry, err);
}
xmmsv_list_iter_explicit_destroy (it);
}
/**
* Sanitize the 'get' property of a 'metadata' fetch specification.
*/
static xmmsv_t *
normalize_metadata_get (xmmsv_t *fetch, xmms_error_t *err)
{
xmmsv_list_iter_t *it;
xmmsv_t *get, *list;
guint32 values;
if (!xmmsv_dict_get (fetch, "get", &get) ||
xmmsv_get_type (get) != XMMSV_TYPE_LIST ||
xmmsv_list_get_size (get) < 1) {
const gchar *message = "'get' must be a non-empty list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
list = xmmsv_new_list ();
values = 0;
/* Scan for duplicates or invalid values */
xmmsv_get_list_iter (get, &it);
while (xmmsv_list_iter_valid (it)) {
const gchar *value = NULL;
guint32 get_as_int, mask;
xmmsv_list_iter_entry_string (it, &value);
if (!metadata_value_from_string (value, &get_as_int)) {
const gchar *message = "'get' entries must be 'id', 'field', 'value' or 'source'.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
xmmsv_unref (list);
return NULL;
}
mask = 1 << (get_as_int + 1);
if (values & mask) {
const gchar *message = "'get' entries must be unique.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
xmmsv_unref (list);
return NULL;
}
values |= mask;
xmmsv_list_append_int (list, get_as_int);
xmmsv_list_iter_next (it);
}
return list;
}
static s4_sourcepref_t *
normalize_source_preferences (xmmsv_t *fetch, s4_sourcepref_t *prefs, xmms_error_t *err)
{
s4_sourcepref_t *sp;
xmmsv_list_iter_t *it;
const char **strv;
const gchar *str;
xmmsv_t *list;
gint length, idx;
if (!xmmsv_dict_get (fetch, "source-preference", &list)) {
return s4_sourcepref_ref (prefs);
}
if (xmmsv_get_type (list) != XMMSV_TYPE_LIST) {
const gchar *message = "'source-preference' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
length = xmmsv_list_get_size (list);
if (length == 0) {
return s4_sourcepref_ref (prefs);
}
strv = g_new0 (const char *, length + 1);
idx = 0;
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_valid (it)) {
if (!xmmsv_list_iter_entry_string (it, &str)) {
const gchar *message = "'source-preference' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_free (strv);
return NULL;
}
strv[idx++] = str;
xmmsv_list_iter_next (it);
}
sp = s4_sourcepref_create (strv);
g_free (strv);
return sp;
}
void
cmd_playlists_list (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
const gchar *active_name;
xmmsc_result_t *res, *active_res;
xmmsv_t *val, *active_val;
xmmsv_list_iter_t *it;
active_res = xmmsc_playlist_current_active (conn);
xmmsc_result_wait (active_res);
active_val = xmmsc_result_get_value (active_res);
if (xmmsv_is_error (active_val) ||
!xmmsv_get_string (active_val, &active_name)) {
active_name = NULL;
}
res = xmmsc_playlist_list (conn);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_is_error (val)) {
print_error ("%s", xmmsv_get_error_old (val));
}
xmmsv_get_list_iter (val, &it);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *valstr;
const gchar *name;
xmmsv_list_iter_entry (it, &valstr);
if (!xmmsv_get_string (valstr, &name)) {
print_error ("Broken resultset");
}
/* Hide all lists that start with _ */
if (name[0] != '_') {
if (active_name != NULL && strcmp (active_name, name) == 0) {
print_info ("->%s", name);
} else {
print_info (" %s", name);
}
}
xmmsv_list_iter_next (it);
}
xmmsc_result_unref (res);
xmmsc_result_unref (active_res);
}
/* (from src/clients/cli/cmd_coll.c) */
static void
coll_dump_list (xmmsv_t *list, unsigned int level)
{
xmmsv_list_iter_t *it;
xmmsv_coll_t *operand;
xmmsv_t *v;
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_entry (it, &v)) {
if (xmmsv_get_coll (v, &operand)) {
coll_dump (operand, level);
}
xmmsv_list_iter_next (it);
}
}
/**
* Checks that the list only contains string values.
*/
gboolean
check_string_list (xmmsv_t *list)
{
xmmsv_t *valstr;
xmmsv_list_iter_t *it;
for (xmmsv_get_list_iter (list, &it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry (it, &valstr);
if (xmmsv_get_type (valstr) != XMMSV_TYPE_STRING) {
return FALSE;
}
}
return TRUE;
}
static GTree *
g_tree_new_from_xmmsv (xmmsv_t *list)
{
xmmsv_list_iter_t *it;
GTree *tree;
gint id;
tree = g_tree_new (g_direct_compare);
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_entry_int (it, &id)) {
g_tree_insert (tree, GINT_TO_POINTER (id), GINT_TO_POINTER (id));
xmmsv_list_iter_next (it);
}
return tree;
}
void
add_list (xmmsc_result_t *matching, cli_infos_t *infos,
gchar *playlist, gint pos)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *insres;
guint id;
gint offset;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (matching);
offset = 0;
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
insres = xmmsc_playlist_insert_id (infos->sync, playlist,
pos + offset, id);
xmmsc_result_wait (insres);
xmmsc_result_unref (insres);
offset++;
}
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
}
/* Apply operation to an idlist */
void
apply_ids (cli_infos_t *infos, xmmsc_result_t *res, idlist_command_t cmd)
{
const gchar *err;
xmmsc_result_t *cmdres;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
guint id;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
switch (cmd) {
case IDLIST_CMD_REHASH:
cmdres = xmmsc_medialib_rehash (infos->sync, id);
break;
case IDLIST_CMD_REMOVE:
cmdres = xmmsc_medialib_remove_entry (infos->sync, id);
break;
default:
break;
}
xmmsc_result_wait (cmdres);
xmmsc_result_unref (cmdres);
}
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
