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; }
Coll::Coll* extract_collection( xmmsv_t* val ) { Coll::Coll* temp = 0; xmmsv_coll_t* coll = 0; xmmsv_get_coll( val, &coll ); switch( xmmsv_coll_get_type( coll ) ) { case XMMS_COLLECTION_TYPE_REFERENCE: { temp = new Coll::Reference( coll ); break; } case XMMS_COLLECTION_TYPE_UNION: { temp = new Coll::Union( coll ); break; } case XMMS_COLLECTION_TYPE_INTERSECTION: { temp = new Coll::Intersection( coll ); break; } case XMMS_COLLECTION_TYPE_COMPLEMENT: { temp = new Coll::Complement( coll ); break; } case XMMS_COLLECTION_TYPE_HAS: { temp = new Coll::Has( coll ); break; } case XMMS_COLLECTION_TYPE_SMALLER: { temp = new Coll::Smaller( coll ); break; } case XMMS_COLLECTION_TYPE_GREATER: { temp = new Coll::Greater( coll ); break; } case XMMS_COLLECTION_TYPE_EQUALS: { temp = new Coll::Equals( coll ); break; } case XMMS_COLLECTION_TYPE_MATCH: { temp = new Coll::Match( coll ); break; } case XMMS_COLLECTION_TYPE_IDLIST: { temp = new Coll::Idlist( coll ); break; } case XMMS_COLLECTION_TYPE_QUEUE: { temp = new Coll::Queue( coll ); break; } case XMMS_COLLECTION_TYPE_PARTYSHUFFLE: { temp = new Coll::PartyShuffle( coll ); break; } } return temp; }
/** * Check if collection is of specified type. * * @param val #xmmsv_t to check. * @param t #xmmsv_coll_type_t to check for. * @return 1 if value is of specified type, 0 otherwise. */ int xmmsv_coll_is_type (xmmsv_t *val, xmmsv_coll_type_t t) { x_api_error_if (!val, "NULL value", 0); return (xmmsv_coll_get_type (val) == t); }
void configure_playlist (xmmsc_result_t *res, cli_infos_t *infos, gchar *playlist, gint history, gint upcoming, xmmsv_coll_type_t type, gchar *input) { xmmsc_result_t *saveres; xmmsv_coll_t *coll; xmmsv_coll_t *newcoll; xmmsv_t *val; gboolean copied = FALSE; val = xmmsc_result_get_value (res); if (xmmsv_get_coll (val, &coll)) { if (type >= 0 && xmmsv_coll_get_type (coll) != type) { newcoll = coll_copy_retype (coll, type); coll = newcoll; copied = TRUE; } if (history >= 0) { coll_int_attribute_set (coll, "history", history); } if (upcoming >= 0) { coll_int_attribute_set (coll, "upcoming", upcoming); } if (input) { /* Replace previous operand. */ newcoll = coll_make_reference (input, XMMS_COLLECTION_NS_COLLECTIONS); xmmsv_list_clear (xmmsv_coll_operands_get (coll)); xmmsv_coll_add_operand (coll, newcoll); xmmsv_coll_unref (newcoll); } saveres = xmmsc_coll_save (infos->sync, coll, playlist, XMMS_COLLECTION_NS_PLAYLISTS); xmmsc_result_wait (saveres); done (saveres, infos); } else { g_printf (_("Cannot find the playlist to configure!\n")); cli_infos_loop_resume (infos); } if (copied) { xmmsv_coll_unref (coll); } 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; }
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; } }
/* Augment the collection with new attributes needed for coll2 */ static xmmsv_t * augment_coll (xmmsv_t *coll) { xmmsv_t *ret = coll; const char *key; switch (xmmsv_coll_get_type (coll)) { case XMMS_COLLECTION_TYPE_HAS: case XMMS_COLLECTION_TYPE_MATCH: case XMMS_COLLECTION_TYPE_TOKEN: case XMMS_COLLECTION_TYPE_EQUALS: case XMMS_COLLECTION_TYPE_NOTEQUAL: case XMMS_COLLECTION_TYPE_SMALLER: case XMMS_COLLECTION_TYPE_SMALLEREQ: case XMMS_COLLECTION_TYPE_GREATER: case XMMS_COLLECTION_TYPE_GREATEREQ: if (xmmsv_coll_attribute_get_string (coll, "field", &key) && strcmp (key, "id") == 0) { xmmsv_coll_attribute_set_string (coll, "type", "id"); } else { xmmsv_coll_attribute_set_string (coll, "type", "value"); } break; case XMMS_COLLECTION_TYPE_REFERENCE: if (xmmsv_coll_attribute_get_string (coll, "reference", &key) && strcmp (key, "All Media") == 0) { ret = xmmsv_new_coll (XMMS_COLLECTION_TYPE_UNIVERSE); xmmsv_unref (coll); } break; default: break; } return ret; }
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 ("}"); }
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; } }
Type Coll::getType() const { return xmmsv_coll_get_type( coll_ ); }
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; }
/** Write the given operator to the database under the given id. * * @param session The medialib session connected to the DB. * @param collid The id under which to save the collection. * @param coll The structure of the collection to save. * @return The next free collection id. */ static guint xmms_collection_dbwrite_operator (xmms_medialib_session_t *session, guint collid, xmmsv_coll_t *coll) { gchar query[128]; guint *idlist; gint i; xmmsv_coll_t *op; xmmsv_t *attrs; gint newid, nextid; coll_dbwrite_t dbwrite_infos = { session, collid, 0 }; /* Write operator */ g_snprintf (query, sizeof (query), "INSERT INTO CollectionOperators VALUES(%d, %d)", collid, xmmsv_coll_get_type (coll)); xmms_medialib_select (session, query, NULL); /* Write attributes */ attrs = xmmsv_coll_attributes_get (coll); xmmsv_dict_foreach (attrs, dbwrite_coll_attributes, &dbwrite_infos); attrs = NULL; /* no unref needed. */ /* Write idlist */ idlist = xmmsv_coll_get_idlist (coll); for (i = 0; idlist[i] != 0; i++) { g_snprintf (query, sizeof (query), "INSERT INTO CollectionIdlists VALUES(%d, %d, %d)", collid, i, idlist[i]); xmms_medialib_select (session, query, NULL); } /* Save operands and connections (don't recurse in ref operand) */ newid = collid + 1; if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) { xmmsv_t *tmp; xmmsv_list_iter_t *iter; 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)) { xmmsv_list_iter_entry (iter, &tmp); xmmsv_get_coll (tmp, &op); nextid = xmms_collection_dbwrite_operator (session, newid, op); g_snprintf (query, sizeof (query), "INSERT INTO CollectionConnections VALUES(%d, %d)", newid, collid); xmms_medialib_select (session, query, NULL); newid = nextid; } xmmsv_list_iter_explicit_destroy (iter); } /* return next available id */ return newid; }
Coll::Coll* extract_collection( xmmsv_t* coll ) { Coll::Coll* temp = 0; switch( xmmsv_coll_get_type( coll ) ) { case XMMS_COLLECTION_TYPE_REFERENCE: { temp = new Coll::Reference( coll ); break; } case XMMS_COLLECTION_TYPE_UNION: { temp = new Coll::Union( coll ); break; } case XMMS_COLLECTION_TYPE_INTERSECTION: { temp = new Coll::Intersection( coll ); break; } case XMMS_COLLECTION_TYPE_COMPLEMENT: { temp = new Coll::Complement( coll ); break; } case XMMS_COLLECTION_TYPE_EQUALS: { temp = new Coll::Equals( coll ); break; } case XMMS_COLLECTION_TYPE_NOTEQUAL: { temp = new Coll::NotEquals( coll ); break; } case XMMS_COLLECTION_TYPE_SMALLER: { temp = new Coll::Smaller( coll ); break; } case XMMS_COLLECTION_TYPE_SMALLEREQ: { temp = new Coll::SmallerEqual( coll ); break; } case XMMS_COLLECTION_TYPE_GREATER: { temp = new Coll::Greater( coll ); break; } case XMMS_COLLECTION_TYPE_GREATEREQ: { temp = new Coll::GreaterEqual( coll ); break; } case XMMS_COLLECTION_TYPE_HAS: { temp = new Coll::Has( coll ); break; } case XMMS_COLLECTION_TYPE_TOKEN: { temp = new Coll::Token( coll ); break; } case XMMS_COLLECTION_TYPE_MATCH: { temp = new Coll::Match( coll ); break; } case XMMS_COLLECTION_TYPE_ORDER: { temp = new Coll::Order( coll ); break; } case XMMS_COLLECTION_TYPE_LIMIT: { temp = new Coll::Limit( coll ); break; } case XMMS_COLLECTION_TYPE_MEDIASET: { temp = new Coll::Mediaset( coll ); break; } case XMMS_COLLECTION_TYPE_IDLIST: { const char *type = NULL; if (!xmmsv_coll_attribute_get_string (coll, "type", &type)) { temp = new Coll::Idlist( coll ); } else if (!strcmp(type, "queue")) { temp = new Coll::Queue( coll ); } else if (!strcmp(type, "partyshuffle")) { temp = new Coll::PartyShuffle( coll ); } else { temp = new Coll::Idlist( coll ); } break; } } return temp; }
/* 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; } }
void cmd_playlist_type (xmmsc_connection_t *conn, gint argc, gchar **argv) { gchar *name; xmmsv_coll_type_t prevtype, newtype; xmmsc_result_t *res; xmmsv_t *val; xmmsv_coll_t *coll; /* Read playlist name */ if (argc < 4) { print_error ("usage: type_playlist [playlistname] [type] [options]"); } name = argv[3]; /* Retrieve the playlist operator */ res = xmmsc_coll_get (conn, name, XMMS_COLLECTION_NS_PLAYLISTS); 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_coll (val, &coll); prevtype = xmmsv_coll_get_type (coll); /* No type argument, simply display the current type */ if (argc < 5) { print_info (get_playlist_type_string (prevtype)); /* Type argument, set the new type */ } else { gint typelen; gint idlistsize; xmmsc_result_t *saveres; xmmsv_coll_t *newcoll; gint i; typelen = strlen (argv[4]); if (g_ascii_strncasecmp (argv[4], "list", typelen) == 0) { newtype = XMMS_COLLECTION_TYPE_IDLIST; } else if (g_ascii_strncasecmp (argv[4], "queue", typelen) == 0) { newtype = XMMS_COLLECTION_TYPE_QUEUE; } else if (g_ascii_strncasecmp (argv[4], "pshuffle", typelen) == 0) { newtype = XMMS_COLLECTION_TYPE_PARTYSHUFFLE; /* Setup operand for party shuffle (set operand) ! */ if (argc < 6) { print_error ("Give the source collection for the party shuffle"); } } else { print_error ("Invalid playlist type (valid types: list, queue, pshuffle)"); } /* Copy collection idlist, attributes and operand (if needed) */ newcoll = xmmsv_coll_new (newtype); idlistsize = xmmsv_coll_idlist_get_size (coll); for (i = 0; i < idlistsize; i++) { guint id; xmmsv_coll_idlist_get_index (coll, i, &id); xmmsv_coll_idlist_append (newcoll, id); } xmmsv_coll_attribute_foreach (coll, coll_copy_attributes, newcoll); if (newtype == XMMS_COLLECTION_TYPE_PARTYSHUFFLE) { playlist_setup_pshuffle (conn, newcoll, argv[5]); } /* Overwrite with new collection */ saveres = xmmsc_coll_save (conn, newcoll, name, XMMS_COLLECTION_NS_PLAYLISTS); xmmsc_result_wait (saveres); if (xmmsc_result_iserror (saveres)) { print_error ("Couldn't save %s : %s", name, xmmsc_result_get_error (saveres)); } xmmsv_coll_unref (newcoll); xmmsc_result_unref (saveres); } xmmsc_result_unref (res); }