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; }
/** * Return a collection with several order-operators added. * * @param coll the original collection * @param order list of ordering strings or dicts. * * @return coll with order-operators added */ xmmsv_t * xmmsv_coll_add_order_operators (xmmsv_t *coll, xmmsv_t *order) { xmmsv_list_iter_t *it; xmmsv_t *current, *value; x_api_error_if (coll == NULL, "with a NULL coll", NULL); xmmsv_ref (coll); if (!order) { return coll; } x_api_error_if (!xmmsv_is_type (order, XMMSV_TYPE_LIST), "with a non list order", coll); current = coll; xmmsv_get_list_iter (order, &it); xmmsv_list_iter_last (it); while (xmmsv_list_iter_entry (it, &value)) { xmmsv_t *ordered; ordered = xmmsv_coll_add_order_operator (current, value); xmmsv_unref (current); current = ordered; xmmsv_list_iter_prev (it); } return current; }
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); } }
/** 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; }
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 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 void xmms_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); }
/** * 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 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 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 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; }
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 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); } }
/** * 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); }