/* call-seq:
* c = Xmms::Collection.universe
*
* Returns a collection referencing the "All Media" set.
*/
static VALUE
c_coll_universe (VALUE klass)
{
VALUE obj = rb_obj_alloc (klass);
RbCollection *coll = NULL;
Data_Get_Struct (obj, RbCollection, coll);
coll->real = xmmsv_new_coll (XMMS_COLLECTION_TYPE_UNIVERSE);
return obj;
}
static xmmsv_t *
duplicate_coll_value (xmmsv_t *val)
{
xmmsv_t *dup_val;
xmmsv_coll_t *new_coll, *orig_coll;
xmmsv_get_coll (val, &orig_coll);
assert (orig_coll);
new_coll = xmmsv_coll_copy (orig_coll);
dup_val = xmmsv_new_coll (new_coll);
return dup_val;
}
/**
* Recursively add files under a path to the media library.
*
* @param medialib the medialib object
* @param path the directory to scan for files
* @param error If an error occurs, it will be stored in there.
*
* @return an IDLIST collection with the added entries
*/
xmmsv_t *
xmms_medialib_add_recursive (xmms_medialib_t *medialib, const gchar *path,
xmms_error_t *error)
{
xmmsv_t *entries;
entries = xmmsv_new_coll (XMMS_COLLECTION_TYPE_IDLIST);
g_return_val_if_fail (medialib, entries);
g_return_val_if_fail (path, entries);
process_dir (medialib, entries, path, error);
return entries;
}
/**
* Return a collection with an order-operator added.
*
* @param coll the original collection
* @param value an ordering string, optionally starting with "-" (for
* descending ordering), followed by a string "id", "random"
* or a key identifying a property, such as "artist" or "album".
* Or it can be a dict containing the attributes to set.
* @return coll with order-operators added
*/
xmmsv_t *
xmmsv_coll_add_order_operator (xmmsv_t *coll, xmmsv_t *value)
{
value = xmmsv_coll_normalize_order_arguments (value);
if (value != NULL) {
xmmsv_t *ordered;
ordered = xmmsv_new_coll (XMMS_COLLECTION_TYPE_ORDER);
xmmsv_coll_add_operand (ordered, coll);
xmmsv_coll_attributes_set (ordered, value);
xmmsv_unref (value);
return ordered;
}
return xmmsv_ref (coll);
}
/* 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
filter_testcase (const gchar *path, xmmsv_t *list)
{
gchar *content, *filename;
xmmsv_t *dict, *data, *holder;
xmmsv_coll_t *coll;
g_assert (g_file_get_contents (path, &content, NULL, NULL));
dict = xmmsv_from_json (content);
if (dict == NULL) {
g_error ("Could not parse '%s'!\n", path);
g_assert_not_reached ();
}
g_free (content);
g_assert (xmmsv_dict_has_key (dict, "medialib"));
g_assert (xmmsv_dict_has_key (dict, "collection"));
g_assert (xmmsv_dict_has_key (dict, "specification"));
g_assert (xmmsv_dict_has_key (dict, "expected"));
g_assert (xmmsv_dict_get (dict, "collection", &data));
g_assert (xmmsv_is_type (data, XMMSV_TYPE_DICT));
coll = xmmsv_coll_from_dict (data);
holder = xmmsv_new_coll (coll);
xmmsv_coll_unref (coll);
xmmsv_dict_set (dict, "collection", holder);
xmmsv_unref (holder);
filename = g_path_get_basename (path);
xmmsv_dict_set_string (dict, "name", filename);
g_free (filename);
xmmsv_list_append (list, dict);
xmmsv_unref (dict);
}
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;
}
static bool
_internal_get_from_bb_value_of_type_alloc (xmmsv_t *bb, xmmsv_type_t type,
xmmsv_t **val)
{
int32_t i;
uint32_t len;
char *s;
xmmsv_coll_t *c;
unsigned char *d;
switch (type) {
case XMMSV_TYPE_ERROR:
if (!_internal_get_from_bb_error_alloc (bb, &s, &len)) {
return false;
}
*val = xmmsv_new_error (s);
free (s);
break;
case XMMSV_TYPE_INT32:
if (!_internal_get_from_bb_int32 (bb, &i)) {
return false;
}
*val = xmmsv_new_int (i);
break;
case XMMSV_TYPE_STRING:
if (!_internal_get_from_bb_string_alloc (bb, &s, &len)) {
return false;
}
*val = xmmsv_new_string (s);
free (s);
break;
case XMMSV_TYPE_DICT:
if (!xmmsc_deserialize_dict (bb, val)) {
return false;
}
break;
case XMMSV_TYPE_LIST :
if (!xmmsc_deserialize_list (bb, val)) {
return false;
}
break;
case XMMSV_TYPE_COLL:
if (!_internal_get_from_bb_collection_alloc (bb, &c)) {
return false;
}
*val = xmmsv_new_coll (c);
xmmsv_coll_unref (c);
break;
case XMMSV_TYPE_BIN:
if (!_internal_get_from_bb_bin_alloc (bb, &d, &len)) {
return false;
}
*val = xmmsv_new_bin (d, len);
free (d);
break;
case XMMSV_TYPE_NONE:
*val = xmmsv_new_none ();
break;
default:
x_internal_error ("Got message of unknown type!");
return false;
}
return true;
}
xmmsv_t *
xmmsv_coll_new (xmmsv_coll_type_t type)
{
return xmmsv_new_coll (type);
}
/**
* Return a collection referencing the whole media library.
* The returned structure must be unref'd using #xmmsv_coll_unref
* after usage.
*
* @return a collection containing all media.
*/
xmmsv_t*
xmmsv_coll_universe ()
{
return xmmsv_new_coll (XMMS_COLLECTION_TYPE_UNIVERSE);
}
