/** * Cancel an idle request * @param request_id A request_id as returned by rs_io_idle_read_complete_file() */ void rs_io_idle_cancel(RSIoJob *job) { /* This behaves like rs_io_idle_cancel_class(), please see comments there */ RSIoJob *current_job; RSIoJob *marker_job = rs_io_job_new(); init(); g_async_queue_lock(queue); /* Put a marker in the queue, we will rotate the complete queue, so we have to know when we're around */ g_async_queue_push_unlocked(queue, marker_job); while((current_job = g_async_queue_pop_unlocked(queue))) { /* If current job matches marker, we're done */ if (current_job == marker_job) break; if (current_job != job) g_async_queue_push_unlocked(queue, current_job); } /* Make sure the queue is sorted */ g_async_queue_sort_unlocked(queue, queue_sort, NULL); g_async_queue_unlock(queue); g_object_unref(marker_job); }
/** * g_async_queue_sort: * @queue: a #GAsyncQueue * @func: the #GCompareDataFunc is used to sort @queue * @user_data: user data passed to @func * * Sorts @queue using @func. * * The sort function @func is passed two elements of the @queue. * It should return 0 if they are equal, a negative value if the * first element should be higher in the @queue or a positive value * if the first element should be lower in the @queue than the second * element. * * This function will lock @queue before it sorts the queue and unlock * it when it is finished. * * If you were sorting a list of priority numbers to make sure the * lowest priority would be at the top of the queue, you could use: * |[<!-- language="C" --> * gint32 id1; * gint32 id2; * * id1 = GPOINTER_TO_INT (element1); * id2 = GPOINTER_TO_INT (element2); * * return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1); * ]| * * Since: 2.10 */ void g_async_queue_sort (GAsyncQueue *queue, GCompareDataFunc func, gpointer user_data) { g_return_if_fail (queue != NULL); g_return_if_fail (func != NULL); g_mutex_lock (&queue->mutex); g_async_queue_sort_unlocked (queue, func, user_data); g_mutex_unlock (&queue->mutex); }
/** * g_thread_pool_set_sort_function: * @pool: a #GThreadPool * @func: the #GCompareDataFunc used to sort the list of tasks. * This function is passed two tasks. It should return * 0 if the order in which they are handled does not matter, * a negative value if the first task should be processed before * the second or a positive value if the second task should be * processed first. * @user_data: user data passed to @func * * Sets the function used to sort the list of tasks. This allows the * tasks to be processed by a priority determined by @func, and not * just in the order in which they were added to the pool. * * Note, if the maximum number of threads is more than 1, the order * that threads are executed cannot be guaranteed 100%. Threads are * scheduled by the operating system and are executed at random. It * cannot be assumed that threads are executed in the order they are * created. * * Since: 2.10 */ void g_thread_pool_set_sort_function (GThreadPool *pool, GCompareDataFunc func, gpointer user_data) { GRealThreadPool *real; real = (GRealThreadPool*) pool; g_return_if_fail (real); g_return_if_fail (real->running); g_async_queue_lock (real->queue); real->sort_func = func; real->sort_user_data = user_data; if (func) g_async_queue_sort_unlocked (real->queue, real->sort_func, real->sort_user_data); g_async_queue_unlock (real->queue); }