/** 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
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);
}
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;
}
static void
cli_jump_relative (cli_context_t *ctx, gint inc, xmmsv_t *value)
{
xmmsc_connection_t *conn = cli_context_xmms_sync (ctx);
xmmsv_list_iter_t *it;
gint i, plid, id, currpos, plsize;
xmmsv_t *playlist;
currpos = cli_context_current_position (ctx);
playlist = cli_context_active_playlist (ctx);
plsize = xmmsv_list_get_size (playlist);
/* If no currpos, start jump from beginning */
if (currpos < 0) {
currpos = 0;
}
/* magic trick so we can loop in either direction */
inc += plsize;
xmmsv_get_list_iter (value, &it);
/* Loop on the playlist */
for (i = (currpos + inc) % plsize; i != currpos; i = (i + inc) % plsize) {
xmmsv_list_iter_first (it);
xmmsv_list_get_int (playlist, i, &plid);
/* Loop on the matched media */
while (xmmsv_list_iter_entry_int (it, &id)) {
/* If both match, jump! */
if (plid == id) {
XMMS_CALL_CHAIN (XMMS_CALL_P (xmmsc_playlist_set_next, conn, i),
XMMS_CALL_P (xmmsc_playback_tickle, conn));
return;
}
xmmsv_list_iter_next (it);
}
}
/* No matching media found, don't jump */
g_printf (_("No media matching the pattern in the playlist!\n"));
}
/* call-seq:
* c.idlist
*
* Gets the list of media ids that make up the collection.
*/
static VALUE
c_coll_idlist_get (VALUE self)
{
VALUE ary = rb_ary_new ();
xmmsv_t *ret = NULL;
xmmsv_list_iter_t *it = NULL;
int32_t entry;
COLL_METHOD_ADD_HANDLER_RET (idlist_get)
xmmsv_get_list_iter (ret, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_list_iter_entry_int (it, &entry);
rb_ary_push (ary, INT2NUM (entry));
}
xmmsv_list_iter_explicit_destroy (it);
return ary;
}
static void
cli_info_print_list (cli_context_t *ctx, xmmsv_t *val)
{
xmmsc_connection_t *conn = cli_context_xmms_sync (ctx);
xmmsv_list_iter_t *it;
gboolean first = TRUE;
gint32 id;
xmmsv_get_list_iter (val, &it);
while (xmmsv_list_iter_entry_int (it, &id)) {
if (!first) {
g_printf ("\n");
} else {
first = FALSE;
}
XMMS_CALL_CHAIN (XMMS_CALL_P (xmmsc_medialib_get_info, conn, id),
FUNC_CALL_P (cli_info_print, XMMS_PREV_VALUE));
xmmsv_list_iter_next (it);
}
}
/* Recursively append conditions corresponding to the given collection to the query. */
static void
xmms_collection_append_to_query (xmms_coll_dag_t *dag, xmmsv_coll_t *coll,
coll_query_t *query)
{
xmmsv_coll_t *op;
xmms_medialib_entry_t entry;
gchar *attr1, *attr2, *attr3;
gboolean case_sens;
xmmsv_list_iter_t *iter;
xmmsv_t *tmp;
gboolean first;
xmmsv_coll_type_t type = xmmsv_coll_get_type (coll);
switch (type) {
case XMMS_COLLECTION_TYPE_REFERENCE:
if (!operator_is_allmedia (coll)) {
query_append_operand (query, dag, coll);
} else {
/* FIXME: Hackish solution to append a ref to All Media */
query_append_string (query, "1");
}
break;
case XMMS_COLLECTION_TYPE_UNION:
case XMMS_COLLECTION_TYPE_INTERSECTION:
first = TRUE;
query_append_string (query, "(");
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &iter);
for (xmmsv_list_iter_first (iter);
xmmsv_list_iter_valid (iter);
xmmsv_list_iter_next (iter)) {
if (first) {
first = FALSE;
} else {
if (type == XMMS_COLLECTION_TYPE_UNION)
query_append_string (query, " OR ");
else
query_append_string (query, " AND ");
}
xmmsv_list_iter_entry (iter, &tmp);
xmmsv_get_coll (tmp, &op);
xmms_collection_append_to_query (dag, op, query);
}
xmmsv_list_iter_explicit_destroy (iter);
query_append_string (query, ")");
break;
case XMMS_COLLECTION_TYPE_COMPLEMENT:
query_append_string (query, "NOT ");
query_append_operand (query, dag, coll);
break;
case XMMS_COLLECTION_TYPE_HAS:
case XMMS_COLLECTION_TYPE_EQUALS:
case XMMS_COLLECTION_TYPE_MATCH:
case XMMS_COLLECTION_TYPE_SMALLER:
case XMMS_COLLECTION_TYPE_GREATER:
xmmsv_coll_attribute_get (coll, "field", &attr1);
xmmsv_coll_attribute_get (coll, "value", &attr2);
xmmsv_coll_attribute_get (coll, "case-sensitive", &attr3);
case_sens = (attr3 != NULL && strcmp (attr3, "true") == 0);
query_append_string (query, "(");
query_append_filter (query, type, attr1, attr2, case_sens);
query_append_intersect_operand (query, dag, coll);
query_append_string (query, ")");
break;
case XMMS_COLLECTION_TYPE_IDLIST:
case XMMS_COLLECTION_TYPE_QUEUE:
case XMMS_COLLECTION_TYPE_PARTYSHUFFLE:
first = TRUE;
query_append_string (query, "m0.id IN (");
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &iter);
for (xmmsv_list_iter_first (iter);
xmmsv_list_iter_valid (iter);
xmmsv_list_iter_next (iter)) {
if (first) {
first = FALSE;
} else {
query_append_string (query, ",");
}
xmmsv_list_iter_entry_int (iter, &entry);
query_append_int (query, entry);
}
xmmsv_list_iter_explicit_destroy (iter);
query_append_string (query, ")");
break;
/* invalid type */
default:
XMMS_DBG ("Cannot append invalid collection operator!");
g_assert_not_reached ();
break;
}
}
static bool
_internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
{
xmmsv_list_iter_t *it;
xmmsv_t *v, *attrs;
int n;
uint32_t ret;
int32_t entry;
xmmsv_coll_t *op;
if (!bb || !coll) {
return false;
}
/* push type */
if (!xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_get_type (coll)))
return false;
/* attribute counter and values */
attrs = xmmsv_coll_attributes_get (coll);
n = 0;
xmmsv_dict_foreach (attrs, _internal_put_on_bb_count_coll_attr, &n);
if (!xmmsv_bitbuffer_put_bits (bb, 32, n))
return false;
/* needs error checking! */
xmmsv_dict_foreach (attrs, _internal_put_on_bb_append_coll_attr, bb);
attrs = NULL; /* no unref needed. */
/* idlist counter and content */
xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_idlist_get_size (coll));
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)) {
if (!xmmsv_list_iter_entry_int (it, &entry)) {
x_api_error ("Non integer in idlist", 0);
}
xmmsv_bitbuffer_put_bits (bb, 32, entry);
}
xmmsv_list_iter_explicit_destroy (it);
/* operands counter and objects */
n = 0;
if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) {
n = xmmsv_list_get_size (xmmsv_coll_operands_get (coll));
}
ret = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, n);
if (n > 0) {
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &it);
while (xmmsv_list_iter_entry (it, &v)) {
if (!xmmsv_get_coll (v, &op)) {
x_api_error ("Non collection operand", 0);
}
_internal_put_on_bb_int32 (bb, XMMSV_TYPE_COLL);
ret = _internal_put_on_bb_collection (bb, op);
xmmsv_list_iter_next (it);
}
}
return ret;
}
