/* Our polling thread */
gpointer apollo_orbiter(gpointer gp_queue)
{
FinishedNotify * pn = gp_queue;
g_async_queue_ref(pn->queue);
while(TRUE)
{
g_print("\n-----------\n\n");
gpointer thread_data = g_async_queue_pop(pn->queue);
if(thread_data == THREAD_TERMINATOR)
{
g_printerr("\n-- Terminating --\n");
break;
}
else
{
GlyrQuery * q = thread_data;
GlyrMemCache * head = glyr_get(q,NULL,NULL);
if(head != NULL)
{
g_print("//////// ITEM %d ////////\n",++pn->counter);
glyr_cache_print(head);
glyr_free_list(head);
g_print("/////////////////////////\n");
}
glyr_query_destroy(q);
}
}
g_async_queue_unref(pn->queue);
return NULL;
}
static gpointer
get_related_info_idle_func (gpointer data)
{
GlyrMemCache *head;
GLYR_ERROR error;
glyr_struct *glyr_info = data;
head = glyr_get (&glyr_info->query, &error, NULL);
glyr_info->head = head;
return glyr_info;
}
void moose_metadata_query_commit(MooseMetadataQuery *self) {
g_assert(self);
MooseMetadataQueryPrivate *priv = moose_metadata_query_get_instance_private(self);
int n_caches = 0;
GlyrMemCache *result = glyr_get(&priv->query, NULL, &n_caches);
for(GlyrMemCache *iter = result; iter; iter = iter->next) {
MooseMetadataCache *cache =
g_object_new(moose_metadata_cache_get_type(), "pointer", iter, NULL);
priv->result_caches = g_list_prepend(priv->result_caches, cache);
}
}
END_TEST
//--------------------
START_TEST(test_glyr_opt_number)
{
GlyrQuery q;
int length = 0;
setup(&q, GLYR_GET_ARTIST_PHOTOS, 4);
GlyrMemCache *list = glyr_get(&q, NULL, &length);
fail_unless(length == 4, NULL);
unsetup(&q, list);
}
END_TEST
//--------------------
START_TEST(test_glyr_opt_proxy)
{
GlyrQuery q;
setup(&q, GLYR_GET_COVERART, 1);
glyr_opt_verbosity(&q, 0);
glyr_opt_proxy(&q, "I can haz Existence?");
GlyrMemCache *list = glyr_get(&q, NULL, NULL);
fail_unless(list == NULL, NULL);
glyr_cache_free(list);
glyr_query_destroy(&q);
}
int main (void)
{
/* Init this thing, the only two methods not being threadsafe */
glyr_init();
/* Also clear ressources on exit */
atexit (glyr_cleanup);
/* This struct is used to store all settings you do via glyr_opt_* */
GlyrQuery q;
/* We also should set it to standard values */
glyr_query_init (&q);
/* We want lyrics, well, I want. */
glyr_opt_type (&q,GLYR_GET_LYRICS);
/* Set random artist/title - you could also omit the album line */
glyr_opt_artist (&q, (char*) "Die Ärzte");
glyr_opt_album (&q, (char*) "Die Bestie in Menschengestalt");
glyr_opt_title (&q, (char*) "FaFaFa");
/* If any error occured it will be saved here, or GLYRE_OK */
/* You could have also passed a NULL pointer to glyr_get() if you're not interested in this */
GLYR_ERROR err;
/* Now get the job done! The 3rd */
GlyrMemCache * head = glyr_get (&q,&err,NULL);
/* The results are stored in the GlyrMemCache struct -
you are most likely only interested in the fields data, size and type*/
if (head != NULL)
{
/* head contains also a pointer to the next element, you can use it therefore as linkedlist */
// puts(head->data);
glyr_cache_print (head);
/* We have to free it again also, you can pass ANY pointer of the list, it works in both directions */
glyr_free_list (head);
}
/* glyr_query_init may allocate memory - free it. */
glyr_query_destroy (&q);
return err;
}
END_TEST
//--------------------
// from
// plugmax
START_TEST(test_glyr_opt_allowed_formats)
{
GlyrQuery q;
setup(&q, GLYR_GET_COVERART, 1);
glyr_opt_verbosity(&q, 0);
glyr_opt_allowed_formats(&q, "png");
int length = 0;
GlyrMemCache *list = glyr_get(&q, NULL, &length);
fail_if(strcmp(list->img_format, "png") != 0, NULL);
unsetup(&q, list);
}
END_TEST
//--------------------
START_TEST(test_glyr_opt_redirects)
{
GlyrQuery q;
setup(&q, GLYR_GET_COVERART, 1);
glyr_opt_from(&q, "amazon");
glyr_opt_redirects(&q, 0);
int length = 0;
GLYR_ERROR err = GLYRE_OK;
GlyrMemCache *list = glyr_get(&q, &err, &length);
fail_unless(list == NULL, "should fail due to redirects");
if(err != GLYRE_OK) {
puts(glyr_strerror(err));
}
unsetup(&q, list);
}
int main(int argc, char *argv[])
{
/* You need to call this before anything happens */
glyr_init();
atexit(glyr_cleanup);
/* Initialize a new query (this may allocate memory) */
GlyrQuery q;
glyr_query_init(&q);
/* Say we want a Songtext */
GLYR_GET_TYPE type = GLYR_GET_LYRICS;
glyr_opt_type(&q, type);
/* Set at least the required fields to your needs *
* For lyrics those are 'artist' and 'title', ('album') *
* is strictly optional and may be used by a few plugins */
glyr_opt_artist(&q, (char *) "Die Apokalyptischen Reiter");
glyr_opt_album(&q, (char *) "Riders on the Storm");
glyr_opt_title(&q, (char *) "Friede sei mit dir");
/* Execute a func when getting one item */
int this_be_my_counter = 0;
glyr_opt_dlcallback(&q, funny_callback, &this_be_my_counter);
/* For the start: Enable verbosity */
glyr_opt_verbosity(&q, 2);
/* Download 5 (or less) items */
glyr_opt_number(&q, 5);
/* Just search, without downloading items */
glyr_opt_download(&q, 0);
/* Call the most important command: GET!
* This returned a list of (GlyrMemCache *)s
* Each containing ONE item. (i.e. a songtext)
*/
GLYR_ERROR err;
GlyrMemCache *it = glyr_get(&q, &err, NULL);
if(err != GLYRE_OK) {
fprintf(stderr, "E:%s\n", glyr_strerror(err));
}
/* Now iterate through it... */
if(it != NULL) {
GlyrMemCache *start = it;
int counter = 0;
while(it != NULL) {
/* This has the same effect as in the callback,
* Just that it's executed just once after all DL is done.
* Commented out, as this would print it twice
* */
print_item(it, counter);
/* Every cache has a link to the next and prev one (or NULL respectively) */
it = it->next;
++counter;
}
/* The contents of it are dynamically allocated. */
/* So better free them if you're not keen on memoryleaks */
glyr_free_list(start);
}
/* Destroy query (reset to default values and free dyn memory) */
/* You could start right off to use this query in another glyr_get */
glyr_query_destroy(&q);
return EXIT_SUCCESS;
}
