static void
run_performance_tests (xmmsv_t *databases, xmmsv_t *testcases, gint format)
{
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (databases, &it);
while (xmmsv_list_iter_valid (it)) {
xmms_medialib_t *medialib;
const gchar *filename;
xmmsv_list_iter_entry_string (it, &filename);
if (format == FORMAT_PRETTY)
g_print ("Running suite with: %s\n", filename);
xmms_ipc_init ();
xmms_config_init ("memory://");
xmms_config_property_register ("medialib.path", filename, NULL, NULL);
medialib = xmms_medialib_init ();
if (medialib == NULL) {
g_print ("Could not open database: %s (%d)\n", filename, s4_errno ());
exit (EXIT_FAILURE);
}
run_tests (medialib, testcases, run_performance_test, format, filename);
xmms_object_unref (medialib);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
xmmsv_list_iter_next (it);
}
}
static xmmsv_t *
normalize_metadata_fields (xmmsv_t *fetch, xmms_error_t *err)
{
gpointer SENTINEL = GINT_TO_POINTER (0x31337);
GHashTable *table;
xmmsv_list_iter_t *it;
xmmsv_t *fields;
if (!xmmsv_dict_get (fetch, "fields", &fields)) {
/* No fields means that we should fetch all fields */
return NULL;
}
if (xmmsv_get_type (fields) != XMMSV_TYPE_LIST) {
const gchar *message = "'fields' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
if (xmmsv_list_get_size (fields) < 1) {
/* No fields means that we should fetch all fields */
return NULL;
}
table = g_hash_table_new (g_str_hash, g_str_equal);
xmmsv_get_list_iter (fields, &it);
while (xmmsv_list_iter_valid (it)) {
const gchar *value = NULL;
if (!xmmsv_list_iter_entry_string (it, &value)) {
const gchar *message = "'fields' entries must be of string type.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_hash_table_unref (table);
return NULL;
}
if (g_hash_table_lookup (table, (gpointer) value) == SENTINEL) {
const gchar *message = "'fields' entries must be unique.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_hash_table_unref (table);
return NULL;
}
g_hash_table_insert (table, (gpointer) value, SENTINEL);
xmmsv_list_iter_next (it);
}
g_hash_table_unref (table);
return fields;
}
static void
cli_info_print (xmmsv_t *propdict)
{
xmmsv_t *properties, *sourcedict, *sources, *value;
xmmsv_list_iter_t *pit, *sit;
const gchar *source, *property;
gint source_width;
GString *sb;
if (!xmmsv_propdict_lengths (propdict, NULL, &source_width)) {
return;
}
sb = g_string_sized_new (source_width);
xmmsv_dict_keys (propdict, &properties);
xmmsv_list_sort (properties, xmmsv_strcmp);
xmmsv_get_list_iter (properties, &pit);
while (xmmsv_list_iter_entry_string (pit, &property)) {
if (xmmsv_dict_get (propdict, property, &sourcedict)) {
xmmsv_dict_keys (sourcedict, &sources);
xmmsv_list_sort (sources, xmmsv_strcmp);
xmmsv_get_list_iter (sources, &sit);
while (xmmsv_list_iter_entry_string (sit, &source)) {
if (xmmsv_dict_get (sourcedict, source, &value)) {
cli_info_pad_source (sb, source_width, source);
xmmsv_print_value (sb->str, property, value);
}
xmmsv_list_iter_next (sit);
}
}
xmmsv_list_iter_next (pit);
}
g_string_free (sb, TRUE);
}
/**
* Sanitize the 'get' property of a 'metadata' fetch specification.
*/
static xmmsv_t *
normalize_metadata_get (xmmsv_t *fetch, xmms_error_t *err)
{
xmmsv_list_iter_t *it;
xmmsv_t *get, *list;
guint32 values;
if (!xmmsv_dict_get (fetch, "get", &get) ||
xmmsv_get_type (get) != XMMSV_TYPE_LIST ||
xmmsv_list_get_size (get) < 1) {
const gchar *message = "'get' must be a non-empty list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
list = xmmsv_new_list ();
values = 0;
/* Scan for duplicates or invalid values */
xmmsv_get_list_iter (get, &it);
while (xmmsv_list_iter_valid (it)) {
const gchar *value = NULL;
guint32 get_as_int, mask;
xmmsv_list_iter_entry_string (it, &value);
if (!metadata_value_from_string (value, &get_as_int)) {
const gchar *message = "'get' entries must be 'id', 'field', 'value' or 'source'.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
xmmsv_unref (list);
return NULL;
}
mask = 1 << (get_as_int + 1);
if (values & mask) {
const gchar *message = "'get' entries must be unique.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
xmmsv_unref (list);
return NULL;
}
values |= mask;
xmmsv_list_append_int (list, get_as_int);
xmmsv_list_iter_next (it);
}
return list;
}
static s4_sourcepref_t *
normalize_source_preferences (xmmsv_t *fetch, s4_sourcepref_t *prefs, xmms_error_t *err)
{
s4_sourcepref_t *sp;
xmmsv_list_iter_t *it;
const char **strv;
const gchar *str;
xmmsv_t *list;
gint length, idx;
if (!xmmsv_dict_get (fetch, "source-preference", &list)) {
return s4_sourcepref_ref (prefs);
}
if (xmmsv_get_type (list) != XMMSV_TYPE_LIST) {
const gchar *message = "'source-preference' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
return NULL;
}
length = xmmsv_list_get_size (list);
if (length == 0) {
return s4_sourcepref_ref (prefs);
}
strv = g_new0 (const char *, length + 1);
idx = 0;
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_valid (it)) {
if (!xmmsv_list_iter_entry_string (it, &str)) {
const gchar *message = "'source-preference' must be a list of strings.";
xmms_error_set (err, XMMS_ERROR_INVAL, message);
g_free (strv);
return NULL;
}
strv[idx++] = str;
xmmsv_list_iter_next (it);
}
sp = s4_sourcepref_create (strv);
g_free (strv);
return sp;
}
