static void
query_append_operand (coll_query_t *query, xmms_coll_dag_t *dag, xmmsv_coll_t *coll)
{
xmmsv_coll_t *op = NULL;
gchar *target_name;
gchar *target_ns;
guint target_nsid;
if (!xmmsv_list_get_coll (xmmsv_coll_operands_get (coll), 0, &op)) {
/* Ref'd coll not saved as operand, look for it */
if (xmmsv_coll_attribute_get (coll, "reference", &target_name) &&
xmmsv_coll_attribute_get (coll, "namespace", &target_ns)) {
target_nsid = xmms_collection_get_namespace_id (target_ns);
op = xmms_collection_get_pointer (dag, target_name, target_nsid);
}
}
/* Append reference operator */
if (op != NULL) {
xmms_collection_append_to_query (dag, op, query);
/* Cannot find reference, append dummy TRUE */
} else {
query_append_string (query, "1");
}
}
static gboolean
xmms_playlist_advance_do (xmms_playlist_t *playlist)
{
gint size, currpos;
gboolean ret = TRUE;
xmmsv_coll_t *plcoll;
const gchar *jumplist;
xmms_error_t err;
xmms_playlist_t *buffer = playlist;
guint newpos;
xmms_error_reset (&err);
plcoll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, NULL);
if (plcoll == NULL) {
ret = FALSE;
} else if ((size = xmms_playlist_coll_get_size (plcoll)) == 0) {
if (xmmsv_coll_attribute_get (plcoll, "jumplist", &jumplist)) {
xmms_playlist_client_load (buffer, jumplist, &err);
if (xmms_error_isok (&err)) {
ret = xmms_playlist_advance_do (playlist);
} else {
ret = FALSE;
}
} else {
ret = FALSE;
}
} else if (!playlist->repeat_one) {
currpos = xmms_playlist_coll_get_currpos (plcoll);
currpos++;
if (currpos == size && !playlist->repeat_all &&
xmmsv_coll_attribute_get (plcoll, "jumplist", &jumplist)) {
xmms_collection_set_int_attr (plcoll, "position", -1);
XMMS_PLAYLIST_CURRPOS_MSG (-1, XMMS_ACTIVE_PLAYLIST);
xmms_playlist_client_load (buffer, jumplist, &err);
if (xmms_error_isok (&err)) {
ret = xmms_playlist_advance_do (playlist);
} else {
ret = FALSE;
}
} else {
newpos = currpos%size;
xmms_collection_set_int_attr (plcoll, "position", newpos);
XMMS_PLAYLIST_CURRPOS_MSG (newpos, XMMS_ACTIVE_PLAYLIST);
ret = (currpos != size) || playlist->repeat_all;
}
}
return ret;
}
/* Determine whether the given operator is a reference to "All Media" */
static gboolean
operator_is_allmedia (xmmsv_coll_t *op)
{
gchar *target_name;
xmmsv_coll_attribute_get (op, "reference", &target_name);
return (target_name != NULL && strcmp (target_name, "All Media") == 0);
}
static void
pl_print_config (xmmsv_coll_t *coll, const char *name)
{
xmmsv_coll_t *op;
xmmsv_coll_type_t type;
gchar *upcoming = NULL;
gchar *history = NULL;
gchar *input = NULL;
gchar *input_ns = NULL;
xmmsv_t *v;
type = xmmsv_coll_get_type (coll);
xmmsv_coll_attribute_get (coll, "upcoming", &upcoming);
xmmsv_coll_attribute_get (coll, "history", &history);
g_printf (_("name: %s\n"), name);
switch (type) {
case XMMS_COLLECTION_TYPE_IDLIST:
g_printf (_("type: list\n"));
break;
case XMMS_COLLECTION_TYPE_QUEUE:
g_printf (_("type: queue\n"));
g_printf (_("history: %s\n"), history);
break;
case XMMS_COLLECTION_TYPE_PARTYSHUFFLE:
if (xmmsv_list_get (xmmsv_coll_operands_get (coll), 0, &v) &&
xmmsv_get_coll (v, &op)) {
xmmsv_coll_attribute_get (op, "reference", &input);
xmmsv_coll_attribute_get (op, "namespace", &input_ns);
}
g_printf (_("type: pshuffle\n"));
g_printf (_("history: %s\n"), history);
g_printf (_("upcoming: %s\n"), upcoming);
g_printf (_("input: %s/%s\n"), input_ns, input);
break;
default:
g_printf (_("type: unknown!\n"));
break;
}
}
static void
xmms_playlist_update_unlocked (xmms_playlist_t *playlist, const gchar *plname)
{
xmmsv_coll_t *plcoll;
const gchar *type = NULL;
plcoll = xmms_playlist_get_coll (playlist, plname, NULL);
if (plcoll) {
xmmsv_coll_attribute_get (plcoll, "type", &type);
if (g_strcmp0 (type, "queue") == 0) {
xmms_playlist_update_queue (playlist, plname, plcoll);
} else if (g_strcmp0 (type, "pshuffle") == 0) {
xmms_playlist_update_partyshuffle (playlist, plname, plcoll);
}
}
}
static gint
xmms_playlist_set_current_position_do (xmms_playlist_t *playlist, guint32 pos,
xmms_error_t *err)
{
gint size;
xmms_medialib_entry_t mid;
xmmsv_coll_t *plcoll;
const gchar *jumplist;
g_return_val_if_fail (playlist, FALSE);
plcoll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, err);
if (plcoll == NULL) {
return 0;
}
size = xmms_playlist_coll_get_size (plcoll);
if (pos == size &&
xmmsv_coll_attribute_get (plcoll, "jumplist", &jumplist)) {
xmms_collection_set_int_attr (plcoll, "position", 0);
XMMS_PLAYLIST_CURRPOS_MSG (0, XMMS_ACTIVE_PLAYLIST);
xmms_playlist_client_load (playlist, jumplist, err);
if (xmms_error_iserror (err)) {
return 0;
}
plcoll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, err);
if (plcoll == NULL) {
return 0;
}
} else if (pos < size) {
XMMS_DBG ("newpos! %d", pos);
xmms_collection_set_int_attr (plcoll, "position", pos);
XMMS_PLAYLIST_CURRPOS_MSG (pos, XMMS_ACTIVE_PLAYLIST);
} else {
xmms_error_set (err, XMMS_ERROR_INVAL,
"Can't set pos outside the current playlist!");
return 0;
}
xmmsv_coll_idlist_get_index (plcoll, pos, &mid);
return mid;
}
static VALUE
c_attrs_aref (VALUE self, VALUE key)
{
RbCollection *coll = NULL;
VALUE tmp;
int s;
const char *value;
StringValue (key);
tmp = rb_iv_get (self, "collection");
Data_Get_Struct (tmp, RbCollection, coll);
s = xmmsv_coll_attribute_get (coll->real, StringValuePtr (key), &value);
if (!s)
return Qnil;
return rb_str_new2 (value);
}
/* 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;
}
}
/* 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)
{
gint i;
xmmsv_coll_t *op;
guint *idlist;
gchar *attr1, *attr2, *attr3;
gboolean case_sens;
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:
i = 0;
query_append_string (query, "(");
xmmsv_coll_operand_list_save (coll);
xmmsv_coll_operand_list_first (coll);
while (xmmsv_coll_operand_list_entry (coll, &op)) {
if (i != 0) {
if (type == XMMS_COLLECTION_TYPE_UNION)
query_append_string (query, " OR ");
else
query_append_string (query, " AND ");
} else {
i = 1;
}
xmms_collection_append_to_query (dag, op, query);
xmmsv_coll_operand_list_next (coll);
}
xmmsv_coll_operand_list_restore (coll);
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:
idlist = xmmsv_coll_get_idlist (coll);
query_append_string (query, "m0.id IN (");
for (i = 0; idlist[i] != 0; ++i) {
if (i != 0) {
query_append_string (query, ",");
}
query_append_uint (query, idlist[i]);
}
query_append_string (query, ")");
break;
/* invalid type */
default:
XMMS_DBG ("Cannot append invalid collection operator!");
g_assert_not_reached ();
break;
}
}
