int
xmmsv_coll_compare (xmmsv_t *a, xmmsv_t *b)
{
xmmsv_coll_type_t type;
xmmsv_t *_a, *_b;
type = xmmsv_coll_get_type (a);
if (xmmsv_coll_get_type (b) != type) {
return 0;
}
_a = xmmsv_coll_idlist_get (a);
_b = xmmsv_coll_idlist_get (b);
if (!xmmsv_compare (_a, _b)) {
return 0;
}
_a = xmmsv_coll_attributes_get (a);
_b = xmmsv_coll_attributes_get (b);
if (!xmmsv_compare (_a, _b)) {
return 0;
}
_a = xmmsv_coll_operands_get (a);
_b = xmmsv_coll_operands_get (b);
if (!xmmsv_compare (_a, _b)) {
return 0;
}
return 1;
}
/**
* 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);
}
/** 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;
}
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;
}
static void
_xmms_coll_dump (xmmsv_t *coll, int indent)
{
xmmsv_t *attributes, *operands, *idlist;
const char *type_str;
printf ("/* collection */ {\n");
type_str = collection_type_string (xmmsv_coll_get_type (coll));
_xmmsv_coll_dump_indent (indent + 1);
printf ("'type': '%s'", type_str);
attributes = xmmsv_coll_attributes_get (coll);
if (xmmsv_dict_get_size (attributes)) {
printf (",\n");
_xmmsv_coll_dump_indent (indent + 1);
printf ("'attributes': ");
xmmsv_dump_indented (attributes, indent + 1);
}
operands = xmmsv_coll_operands_get (coll);
if (xmmsv_list_get_size (operands)) {
printf (",\n");
_xmmsv_coll_dump_indent (indent + 1);
printf ("'operands': ");
xmmsv_dump_indented (operands, indent + 1);
}
idlist = xmmsv_coll_idlist_get (coll);
if (xmmsv_list_get_size (idlist)) {
printf (",\n");
_xmmsv_coll_dump_indent (indent + 1);
printf ("'idlist': ");
xmmsv_dump_indented (idlist, indent + 1);
}
printf ("\n");
_xmmsv_coll_dump_indent (indent);
printf ("}");
}
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 xmmsv_t *
duplicate_coll_value (xmmsv_t *val)
{
xmmsv_t *dup_val, *attributes, *operands, *idlist, *copy;
dup_val = xmmsv_new_coll (xmmsv_coll_get_type (val));
attributes = xmmsv_coll_attributes_get (val);
copy = xmmsv_copy (attributes);
xmmsv_coll_attributes_set (dup_val, copy);
xmmsv_unref (copy);
operands = xmmsv_coll_operands_get (val);
copy = xmmsv_copy (operands);
xmmsv_coll_operands_set (dup_val, copy);
xmmsv_unref (copy);
idlist = xmmsv_coll_idlist_get (val);
copy = xmmsv_copy (idlist);
xmmsv_coll_idlist_set (dup_val, copy);
xmmsv_unref (copy);
return dup_val;
}
/* 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;
}
}
/** Sorts the playlist by properties.
*
* This will sort the list.
* @param playlist The playlist to sort.
* @param properties Tells xmms_playlist_sort which properties it
* should use when sorting.
* @param err An #xmms_error_t - needed since xmms_playlist_sort is an ipc
* method handler.
*/
static void
xmms_playlist_client_sort (xmms_playlist_t *playlist, const gchar *plname,
xmmsv_t *properties, xmms_error_t *err)
{
xmmsv_t *tmp, *idlist, *val, *spec, *metadata, *get;
xmmsv_coll_t *plcoll, *ordered;
gint currpos, pos;
xmms_medialib_entry_t currid;
g_return_if_fail (playlist);
g_return_if_fail (properties);
if (xmmsv_list_get_size (properties) < 1) {
xmms_error_set (err, XMMS_ERROR_NOENT,
"need at least one property to sort");
return;
}
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist!");
g_mutex_unlock (playlist->mutex);
return;
}
currpos = xmms_playlist_coll_get_currpos (plcoll);
xmmsv_coll_idlist_get_index (plcoll, currpos, &currid);
get = xmmsv_new_list ();
xmmsv_list_append_string (get, "id");
metadata = xmmsv_new_dict ();
xmmsv_dict_set_string (metadata, "type", "metadata");
xmmsv_dict_set_string (metadata, "aggregate", "first");
xmmsv_dict_set (metadata, "get", get);
xmmsv_unref (get);
spec = xmmsv_new_dict ();
xmmsv_dict_set_string (spec, "type", "cluster-list");
xmmsv_dict_set_string (spec, "cluster-by", "position");
xmmsv_dict_set (spec, "data", metadata);
xmmsv_unref (metadata);
ordered = xmmsv_coll_add_order_operators (plcoll, properties);
MEDIALIB_BEGIN (playlist->medialib);
tmp = xmms_medialib_query (session, ordered, spec, err);
MEDIALIB_COMMIT ();
xmmsv_coll_unref (ordered);
xmmsv_unref (spec);
if (tmp == NULL) {
g_mutex_unlock (playlist->mutex);
return;
}
idlist = xmmsv_coll_idlist_get (plcoll);
xmmsv_list_clear (idlist);
for (pos = 0; xmmsv_list_get (tmp, pos, &val); pos++) {
xmms_medialib_entry_t id;
xmmsv_get_int (val, &id);
xmmsv_list_append (idlist, val);
if (id == currid) {
xmms_collection_set_int_attr (plcoll, "position", pos);
currpos = pos;
}
}
xmmsv_unref (tmp);
XMMS_PLAYLIST_CHANGED_MSG (XMMS_PLAYLIST_CHANGED_SORT, 0, plname);
XMMS_PLAYLIST_CURRPOS_MSG (currpos, plname);
g_mutex_unlock (playlist->mutex);
}
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;
}