/* GIO - GLib Input, Output and Streaming Library

 * 

 * Copyright (C) 2006-2007 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include "gioscheduler.h"

#include "gcancellable.h"

#include "gtask.h"

/**

 * SECTION:gioscheduler

 * @short_description: I/O Scheduler

 * @include: gio/gio.h

 * 

 * As of GLib 2.36, #GIOScheduler is deprecated in favor of

 * #GThreadPool and #GTask.

 *

 * Schedules asynchronous I/O operations. #GIOScheduler integrates 

 * into the main event loop (#GMainLoop) and uses threads.

 */

struct _GIOSchedulerJob {

  GList *active_link;

  GTask *task;

  GIOSchedulerJobFunc job_func;

  gpointer data;

  GDestroyNotify destroy_notify;

  GCancellable *cancellable;

  gulong cancellable_id;

  GMainContext *context;

};

G_LOCK_DEFINE_STATIC(active_jobs);

static GList *active_jobs = NULL;

static void

g_io_job_free (GIOSchedulerJob *job)

{

  if (job->destroy_notify)

    job->destroy_notify (job->data);

  G_LOCK (active_jobs);

  active_jobs = g_list_delete_link (active_jobs, job->active_link);

  G_UNLOCK (active_jobs);

  if (job->cancellable)

    g_object_unref (job->cancellable);

  g_main_context_unref (job->context);

  g_slice_free (GIOSchedulerJob, job);

}

static void

io_job_thread (GTask         *task,

               gpointer       source_object,

               gpointer       task_data,

               GCancellable  *cancellable)

{

  GIOSchedulerJob *job = task_data;

  gboolean result;

  if (job->cancellable)

    g_cancellable_push_current (job->cancellable);

  do 

    {

      result = job->job_func (job, job->cancellable, job->data);

    }

  while (result);

  if (job->cancellable)

    g_cancellable_pop_current (job->cancellable);

}

/**

 * g_io_scheduler_push_job:

 * @job_func: a #GIOSchedulerJobFunc.

 * @user_data: data to pass to @job_func

 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL

 * @io_priority: the [I/O priority][io-priority]

 * of the request.

 * @cancellable: optional #GCancellable object, %NULL to ignore.

 *

 * Schedules the I/O job to run in another thread.

 *

 * @notify will be called on @user_data after @job_func has returned,

 * regardless whether the job was cancelled or has run to completion.

 * 

 * If @cancellable is not %NULL, it can be used to cancel the I/O job

 * by calling g_cancellable_cancel() or by calling 

 * g_io_scheduler_cancel_all_jobs().

 *

 * Deprecated: use #GThreadPool or g_task_run_in_thread()

 **/

void

g_io_scheduler_push_job (GIOSchedulerJobFunc  job_func,

       gpointer             user_data,

       GDestroyNotify       notify,

       gint                 io_priority,

       GCancellable        *cancellable)

{

  GIOSchedulerJob *job;

  GTask *task;

  g_return_if_fail (job_func != NULL);

  job = g_slice_new0 (GIOSchedulerJob);

  job->job_func = job_func;

  job->data = user_data;

  job->destroy_notify = notify;

  if (cancellable)

    job->cancellable = g_object_ref (cancellable);

  job->context = g_main_context_ref_thread_default ();

  G_LOCK (active_jobs);

  active_jobs = g_list_prepend (active_jobs, job);

  job->active_link = active_jobs;

  G_UNLOCK (active_jobs);

  task = g_task_new (NULL, cancellable, NULL, NULL);

G_GNUC_BEGIN_IGNORE_DEPRECATIONS

  g_task_set_source_tag (task, g_io_scheduler_push_job);

G_GNUC_END_IGNORE_DEPRECATIONS

  g_task_set_task_data (task, job, (GDestroyNotify)g_io_job_free);

  g_task_set_priority (task, io_priority);

  g_task_run_in_thread (task, io_job_thread);

  g_object_unref (task);

}

/**

 * g_io_scheduler_cancel_all_jobs:

 * 

 * Cancels all cancellable I/O jobs. 

 *

 * A job is cancellable if a #GCancellable was passed into

 * g_io_scheduler_push_job().

 *

 * Deprecated: You should never call this function, since you don't

 * know how other libraries in your program might be making use of

 * gioscheduler.

 **/

void

g_io_scheduler_cancel_all_jobs (void)

{

  GList *cancellable_list, *l;

  G_LOCK (active_jobs);

  cancellable_list = NULL;

  for (l = active_jobs; l != NULL; l = l->next)

    {

      GIOSchedulerJob *job = l->data;

      if (job->cancellable)

  cancellable_list = g_list_prepend (cancellable_list,

             g_object_ref (job->cancellable));

    }

  G_UNLOCK (active_jobs);

  for (l = cancellable_list; l != NULL; l = l->next)

    {

      GCancellable *c = l->data;

      g_cancellable_cancel (c);

      g_object_unref (c);

    }

  g_list_free (cancellable_list);

}

typedef struct {

  GSourceFunc func;

  gboolean ret_val;

  gpointer data;

  GDestroyNotify notify;

  GMutex ack_lock;

  GCond ack_condition;

  gboolean ack;

} MainLoopProxy;

static gboolean

mainloop_proxy_func (gpointer data)

{

  MainLoopProxy *proxy = data;

  proxy->ret_val = proxy->func (proxy->data);

  if (proxy->notify)

    proxy->notify (proxy->data);

  g_mutex_lock (&proxy->ack_lock);

  proxy->ack = TRUE;

  g_cond_signal (&proxy->ack_condition);

  g_mutex_unlock (&proxy->ack_lock);

  return FALSE;

}

static void

mainloop_proxy_free (MainLoopProxy *proxy)

{

  g_mutex_clear (&proxy->ack_lock);

  g_cond_clear (&proxy->ack_condition);

  g_free (proxy);

}

/**

 * g_io_scheduler_job_send_to_mainloop:

 * @job: a #GIOSchedulerJob

 * @func: a #GSourceFunc callback that will be called in the original thread

 * @user_data: data to pass to @func

 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL

 * 

 * Used from an I/O job to send a callback to be run in the thread

 * that the job was started from, waiting for the result (and thus

 * blocking the I/O job).

 *

 * Returns: The return value of @func

 *

 * Deprecated: Use g_main_context_invoke().

 **/

gboolean

g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,

             GSourceFunc      func,

             gpointer         user_data,

             GDestroyNotify   notify)

{

  GSource *source;

  MainLoopProxy *proxy;

  gboolean ret_val;

  g_return_val_if_fail (job != NULL, FALSE);

  g_return_val_if_fail (func != NULL, FALSE);

  proxy = g_new0 (MainLoopProxy, 1);

  proxy->func = func;

  proxy->data = user_data;

  proxy->notify = notify;

  g_mutex_init (&proxy->ack_lock);

  g_cond_init (&proxy->ack_condition);

  g_mutex_lock (&proxy->ack_lock);

  source = g_idle_source_new ();

  g_source_set_priority (source, G_PRIORITY_DEFAULT);

  g_source_set_callback (source, mainloop_proxy_func, proxy,

       NULL);

  g_source_set_name (source, "[gio] mainloop_proxy_func");

  g_source_attach (source, job->context);

  g_source_unref (source);

  while (!proxy->ack)

    g_cond_wait (&proxy->ack_condition, &proxy->ack_lock);

  g_mutex_unlock (&proxy->ack_lock);

  ret_val = proxy->ret_val;

  mainloop_proxy_free (proxy);

  return ret_val;

}

/**

 * g_io_scheduler_job_send_to_mainloop_async:

 * @job: a #GIOSchedulerJob

 * @func: a #GSourceFunc callback that will be called in the original thread

 * @user_data: data to pass to @func

 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL

 * 

 * Used from an I/O job to send a callback to be run asynchronously in

 * the thread that the job was started from. The callback will be run

 * when the main loop is available, but at that time the I/O job might

 * have finished. The return value from the callback is ignored.

 *

 * Note that if you are passing the @user_data from g_io_scheduler_push_job()

 * on to this function you have to ensure that it is not freed before

 * @func is called, either by passing %NULL as @notify to 

 * g_io_scheduler_push_job() or by using refcounting for @user_data.

 *

 * Deprecated: Use g_main_context_invoke().

 **/

void

g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,

             GSourceFunc      func,

             gpointer         user_data,

             GDestroyNotify   notify)

{

  GSource *source;

  MainLoopProxy *proxy;

  g_return_if_fail (job != NULL);

  g_return_if_fail (func != NULL);

  proxy = g_new0 (MainLoopProxy, 1);

  proxy->func = func;

  proxy->data = user_data;

  proxy->notify = notify;

  g_mutex_init (&proxy->ack_lock);

  g_cond_init (&proxy->ack_condition);

  source = g_idle_source_new ();

  g_source_set_priority (source, G_PRIORITY_DEFAULT);

  g_source_set_callback (source, mainloop_proxy_func, proxy,

       (GDestroyNotify)mainloop_proxy_free);

  g_source_set_name (source, "[gio] mainloop_proxy_func");

  g_source_attach (source, job->context);

  g_source_unref (source);

}