[tracker/miner-web: 24/26] libtracker-miner: Make TrackerMiner use standard gio callbacks and port TrackerMinerFS



commit c05a3f9975b67bff7eb6d6fd9bea32dde18cb56e
Author: Adrien Bustany <madcat mymadcat com>
Date:   Tue Nov 10 12:59:48 2009 -0300

    libtracker-miner: Make TrackerMiner use standard gio callbacks and port TrackerMinerFS
    
    TrackerMiner previously used custom callbacks for its async calls
    tracker_miner_execute_sparql, tracker_miner_execute_update etc. This commit
    changes the API to make them use the standard GLib callback pattern
    my_callback (GObject *source, GAsyncResult *result, gpointer user_data) .
    The API of TrackerMinerFS is not changed, but it's internaly ported to the
    new functions.

 src/libtracker-miner/tracker-miner-fs.c |  105 ++++++++------
 src/libtracker-miner/tracker-miner.c    |  251 ++++++++++++++++++++++++-------
 src/libtracker-miner/tracker-miner.h    |   66 +++++----
 3 files changed, 291 insertions(+), 131 deletions(-)
---
diff --git a/src/libtracker-miner/tracker-miner-fs.c b/src/libtracker-miner/tracker-miner-fs.c
index d59a6cb..9d7dabc 100644
--- a/src/libtracker-miner/tracker-miner-fs.c
+++ b/src/libtracker-miner/tracker-miner-fs.c
@@ -590,7 +590,7 @@ fs_get_property (GObject    *object,
 	}
 }
 
-static gboolean 
+static gboolean
 fs_defaults (TrackerMinerFS *fs,
 	     GFile          *file)
 {
@@ -614,8 +614,8 @@ miner_started (TrackerMiner *miner)
 
 	fs->private->been_started = TRUE;
 
-	g_object_set (miner, 
-		      "progress", 0.0, 
+	g_object_set (miner,
+		      "progress", 0.0,
 		      "status", _("Initializing"),
 		      NULL);
 
@@ -625,8 +625,8 @@ miner_started (TrackerMiner *miner)
 static void
 miner_stopped (TrackerMiner *miner)
 {
-	g_object_set (miner, 
-		      "progress", 1.0, 
+	g_object_set (miner,
+		      "progress", 1.0,
 		      "status", _("Idle"),
 		      NULL);
 }
@@ -719,17 +719,22 @@ process_print_stats (TrackerMinerFS *fs)
 }
 
 static void
-commit_cb (TrackerMiner *miner,
-	   const GError *error,
-	   gpointer      user_data)
+commit_cb (GObject      *object,
+           GAsyncResult *result,
+           gpointer      user_data)
 {
+	TrackerMiner *miner = TRACKER_MINER (object);
+	GError *error = NULL;
+
+	tracker_miner_commit_finish (miner, result, &error);
+
 	if (error) {
 		g_critical ("Could not commit: %s", error->message);
 	}
 }
 
 static void
-process_stop (TrackerMinerFS *fs) 
+process_stop (TrackerMinerFS *fs)
 {
 	/* Now we have finished crawling, print stats and enable monitor events */
 	process_print_stats (fs);
@@ -738,8 +743,8 @@ process_stop (TrackerMinerFS *fs)
 
 	g_message ("Idle");
 
-	g_object_set (fs, 
-		      "progress", 1.0, 
+	g_object_set (fs,
+		      "progress", 1.0,
 		      "status", _("Idle"),
 		      NULL);
 
@@ -785,15 +790,19 @@ item_moved_data_free (ItemMovedData *data)
 }
 
 static void
-sparql_update_cb (TrackerMiner *miner,
-		  const GError *error,
-		  gpointer      user_data)
+sparql_update_cb (GObject      *object,
+                  GAsyncResult *result,
+                  gpointer      user_data)
 {
 	TrackerMinerFS *fs;
 	TrackerMinerFSPrivate *priv;
 	ProcessData *data;
 
-	fs = TRACKER_MINER_FS (miner);
+	GError *error = NULL;
+
+	tracker_miner_execute_update_finish (TRACKER_MINER (object), result, &error);
+
+	fs = TRACKER_MINER_FS (object);
 	priv = fs->private;
 	data = user_data;
 
@@ -815,14 +824,18 @@ sparql_update_cb (TrackerMiner *miner,
 }
 
 static void
-sparql_query_cb (TrackerMiner *miner,
-		 GPtrArray    *result,
-		 const GError *error,
-		 gpointer      user_data)
+sparql_query_cb (GObject      *object,
+                 GAsyncResult *result,
+                 gpointer      user_data)
 {
 	SparqlQueryData *data = user_data;
+	TrackerMiner *miner = TRACKER_MINER (object);
+
+	GError *error = NULL;
+
+	GPtrArray *query_results = tracker_miner_execute_sparql_finish (miner, result, &error);
 
-	data->value = result && result->len == 1;
+	data->value = query_results && query_results->len == 1;
 	g_main_loop_quit (data->main_loop);
 }
 
@@ -1008,24 +1021,26 @@ item_remove (TrackerMinerFS *fs,
 }
 
 static void
-item_update_uri_recursively_cb (TrackerMiner *miner,
-				GPtrArray    *result,
-				const GError *error,
-				gpointer      user_data)
+item_update_uri_recursively_cb (GObject      *object,
+                                GAsyncResult *result,
+                                gpointer      user_data)
 {
-	TrackerMinerFS *fs = TRACKER_MINER_FS (miner);
+	TrackerMinerFS *fs = TRACKER_MINER_FS (object);
 	RecursiveMoveData *data = user_data;
+	GError *error = NULL;
+
+	GPtrArray *query_results = tracker_miner_execute_sparql_finish (TRACKER_MINER (object), result, &error);
 
 	if (error) {
 		g_critical ("Could not query children: %s", error->message);
 	} else {
-		if (result) {
+		if (query_results) {
 			gint i;
 
 			for (i = 0; i < result->len; i++) {
 				gchar **child_source_uri, *child_uri;
 
-				child_source_uri = g_ptr_array_index (result, i);
+				child_source_uri = g_ptr_array_index (query_results, i);
 
 				if (!g_str_has_prefix (*child_source_uri, data->source_uri)) {
 					g_warning ("Child URI '%s' does not start with parent URI '%s'",
@@ -1218,7 +1233,7 @@ item_queue_get_progress (TrackerMinerFS *fs)
 {
 	guint items_to_process = 0;
 	guint items_total = 0;
-	
+
 	items_to_process += g_queue_get_length (fs->private->items_deleted);
 	items_to_process += g_queue_get_length (fs->private->items_created);
 	items_to_process += g_queue_get_length (fs->private->items_updated);
@@ -1374,10 +1389,10 @@ should_change_index_for_file (TrackerMinerFS *fs,
 	gchar              *query, *uri;
 	SparqlQueryData     data;
 
-	file_info = g_file_query_info (file, 
-				       G_FILE_ATTRIBUTE_TIME_MODIFIED, 
-				       G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, 
-				       NULL, 
+	file_info = g_file_query_info (file,
+				       G_FILE_ATTRIBUTE_TIME_MODIFIED,
+				       G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+				       NULL,
 				       NULL);
 	if (!file_info) {
 		/* NOTE: We return TRUE here because we want to update the DB
@@ -1485,7 +1500,7 @@ monitor_item_created_cb (TrackerMonitor *monitor,
 		} else {
 			g_queue_push_tail (fs->private->items_created,
 					   g_object_ref (file));
-			
+
 			item_queue_handlers_set_up (fs);
 		}
 	}
@@ -1555,17 +1570,17 @@ monitor_item_deleted_cb (TrackerMonitor *monitor,
 	/* Remove directory from list of directories we are going to
 	 * iterate if it is in there.
 	 */
-	l = g_list_find_custom (fs->private->directories, 
-				path, 
+	l = g_list_find_custom (fs->private->directories,
+				path,
 				(GCompareFunc) g_strcmp0);
 
 	/* Make sure we don't remove the current device we are
 	 * processing, this is because we do this same clean up later
-	 * in process_device_next() 
+	 * in process_device_next()
 	 */
 	if (l && l != fs->private->current_directory) {
 		directory_data_free (l->data);
-		fs->private->directories = 
+		fs->private->directories =
 			g_list_delete_link (fs->private->directories, l);
 	}
 #endif
@@ -1591,7 +1606,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
 
 			path = g_file_get_path (other_file);
 
-			g_debug ("Not in store:'?'->'%s' (DIR) (move monitor event, source unknown)", 
+			g_debug ("Not in store:'?'->'%s' (DIR) (move monitor event, source unknown)",
 				 path);
 
 			/* If the source is not monitored, we need to crawl it. */
@@ -1628,12 +1643,12 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
 		} else if (!source_stored) {
 			/* Source file was not stored, check dest file as new */
 			if (!is_directory) {
-				g_queue_push_tail (fs->private->items_created, 
+				g_queue_push_tail (fs->private->items_created,
 						   g_object_ref (other_file));
-				
+
 				item_queue_handlers_set_up (fs);
 			} else {
-				g_debug ("Not in store:'?'->'%s' (DIR) (move monitor event, source monitored)", 
+				g_debug ("Not in store:'?'->'%s' (DIR) (move monitor event, source monitored)",
 					 path);
 
 				tracker_miner_fs_add_directory (fs, other_file, TRUE);
@@ -1641,7 +1656,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
 		} else if (!should_process_other) {
 			/* Delete old file */
 			g_queue_push_tail (fs->private->items_deleted, g_object_ref (file));
-			
+
 			item_queue_handlers_set_up (fs);
 		} else {
 			/* Move old file to new file */
@@ -1650,7 +1665,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
 
 			item_queue_handlers_set_up (fs);
 		}
-		
+
 		g_free (other_path);
 		g_free (path);
 	}
@@ -1691,7 +1706,7 @@ crawler_check_directory_cb (TrackerCrawler *crawler,
 	g_signal_emit (fs, signals[MONITOR_DIRECTORY], 0, file, &add_monitor);
 
 	/* FIXME: Should we add here or when we process the queue in
-	 * the finished sig? 
+	 * the finished sig?
 	 */
 	if (add_monitor) {
 		tracker_monitor_add (fs->private->monitor, file);
@@ -1703,7 +1718,7 @@ crawler_check_directory_cb (TrackerCrawler *crawler,
 	 * is not done recursively.
 	 *
 	 * As such, we only use the "check" rules here, we don't do
-	 * any database comparison with mtime. 
+	 * any database comparison with mtime.
 	 */
 	return should_check;
 }
diff --git a/src/libtracker-miner/tracker-miner.c b/src/libtracker-miner/tracker-miner.c
index c807cd8..45bced9 100644
--- a/src/libtracker-miner/tracker-miner.c
+++ b/src/libtracker-miner/tracker-miner.c
@@ -47,11 +47,11 @@ static GQuark miner_error_quark = 0;
 
 struct TrackerMinerPrivate {
 	TrackerClient *client;
-	
+
 	GHashTable *pauses;
 
 	gboolean started;
-	
+
 	gchar *name;
 	gchar *status;
 	gdouble progress;
@@ -64,7 +64,7 @@ struct TrackerMinerPrivate {
 typedef struct {
 	gint cookie;
 	gchar *application;
-	gchar *reason;	
+	gchar *reason;
 } PauseData;
 
 typedef struct {
@@ -72,10 +72,10 @@ typedef struct {
 	GCancellable *cancellable;
 	gpointer callback;
 	gpointer user_data;
+	gpointer source_function;
 
 	guint id;
 	guint signal_id;
-	gboolean update;
 } AsyncCallData;
 
 enum {
@@ -475,7 +475,7 @@ static void
 pause_data_destroy (gpointer data)
 {
 	PauseData *pd;
-	
+
 	pd = data;
 
 	g_free (pd->reason);
@@ -564,27 +564,55 @@ static void
 run_update_callback (AsyncCallData *data,
 		     const GError  *error)
 {
-	TrackerMinerUpdateCallback callback;
-
+	GAsyncReadyCallback callback;
 	callback = data->callback;
+	GSimpleAsyncResult *result = NULL;
 
-	if (callback) {
-		(callback) (data->miner, error, data->user_data);
+	if (error) {
+		GError *local_error = g_error_copy (error);
+		result = g_simple_async_result_new_from_error (G_OBJECT (data->miner),
+		                                               callback,
+		                                               data->user_data,
+		                                               local_error);
+	} else {
+		result = g_simple_async_result_new (G_OBJECT (data->miner),
+		                                    callback,
+											data->user_data,
+											data->source_function);
 	}
+
+	g_simple_async_result_complete (result);
+	g_object_unref (result);
 }
 
 static void
 run_query_callback (AsyncCallData *data,
-		    GPtrArray     *result,
+		    GPtrArray     *query_results,
 		    const GError  *error)
 {
-	TrackerMinerQueryCallback callback;
+	GAsyncReadyCallback callback;
 
 	callback = data->callback;
 
-	if (callback) {
-		(callback) (data->miner, result, error, data->user_data);
+	GSimpleAsyncResult *result = NULL;
+
+	if (error) {
+		GError *local_error = g_error_copy (error);
+		result = g_simple_async_result_new_from_error (G_OBJECT (data->miner),
+		                                               callback,
+		                                               data->user_data,
+		                                               local_error);
+	} else {
+		result = g_simple_async_result_new (G_OBJECT (data->miner),
+		                                    callback,
+											data->user_data,
+											data->source_function);
 	}
+
+	// FIXME : Not sure the destroy function should be null here
+	g_simple_async_result_set_op_res_gpointer (result, query_results, NULL);
+	g_simple_async_result_complete (result);
+	g_object_unref (result);
 }
 
 static void
@@ -640,7 +668,7 @@ async_call_data_new (TrackerMiner *miner,
 		     GCancellable *cancellable,
 		     gpointer      callback,
 		     gpointer      user_data,
-		     gboolean      update)
+			 gpointer      source_function)
 {
 	AsyncCallData *data;
 
@@ -648,7 +676,7 @@ async_call_data_new (TrackerMiner *miner,
 	data->miner = miner;
 	data->callback = callback;
 	data->user_data = user_data;
-	data->update = update;
+	data->source_function = source_function;
 
 	if (cancellable) {
 		data->cancellable = g_object_ref (cancellable);
@@ -680,7 +708,9 @@ async_call_notify_error (AsyncCallData *data,
 	if (data->callback) {
 		error = g_error_new_literal (miner_error_quark, code, message);
 
-		if (data->update) {
+		if (data->source_function == tracker_miner_execute_update ||
+		    data->source_function == tracker_miner_execute_batch_update ||
+		    data->source_function == tracker_miner_commit) {
 			run_update_callback (data, error);
 		} else {
 			run_query_callback (data, NULL, error);
@@ -695,21 +725,25 @@ async_call_notify_error (AsyncCallData *data,
  * @miner: a #TrackerMiner
  * @sparql: a SPARQL query
  * @cancellable: a #GCancellable to control the operation
- * @callback: a #TrackerMinerUpdateCallback to call when the operation is finished
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished
  * @user_data: data to pass to @callback
  *
  * Executes an update SPARQL query on tracker-store, use this
  * whenever you want to perform data insertions or modifications.
  *
- * When the operation is finished, @callback will be called, providing the error, if any.
- * If the operation is cancelled, @callback will be called anyways, with error filled in.
+ * When the operation is finished, @callback will be called, providing a #GAsyncResult
+ * object. Call tracker_miner_execute_sparql_finish on it to get the returned #GError,
+ * if there is one.
+ *
+ * If the operation is cancelled, @callback will be called anyway, with the #GAsyncResult
+ * object containing an error.
  **/
 void
-tracker_miner_execute_update (TrackerMiner               *miner,
-			      const gchar                *sparql,
-			      GCancellable               *cancellable,
-			      TrackerMinerUpdateCallback  callback,
-			      gpointer                    user_data)
+tracker_miner_execute_update (TrackerMiner        *miner,
+                              const gchar         *sparql,
+                              GCancellable        *cancellable,
+                              GAsyncReadyCallback  callback,
+                              gpointer             user_data)
 {
 	TrackerMinerPrivate *priv;
 	AsyncCallData *data;
@@ -719,11 +753,36 @@ tracker_miner_execute_update (TrackerMiner               *miner,
 	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
 	priv = TRACKER_MINER_GET_PRIVATE (miner);
-	data = async_call_data_new (miner, cancellable, callback, user_data, TRUE);
+	data = async_call_data_new (miner,
+	                            cancellable,
+	                            callback,
+	                            user_data,
+	                            tracker_miner_execute_sparql);
 
 	data->id = tracker_resources_sparql_update_async (miner->private->client,
-							  sparql, sparql_update_cb,
-							  data);
+	                                                  sparql,
+	                                                  sparql_update_cb,
+	                                                  data);
+}
+
+/**
+ * tracker_miner_execute_update_finish:
+ * @miner: a #TrackerMiner
+ * @result: a #GAsyncResult
+ * @error: a #GError
+ *
+ * Finishes the async update operation. If an error occured during the update,
+ * @error will be set.
+ *
+ **/
+void
+tracker_miner_execute_update_finish (TrackerMiner *miner,
+                                     GAsyncResult *result,
+                                     GError      **error)
+{
+	GSimpleAsyncResult *r = G_SIMPLE_ASYNC_RESULT (result);
+
+	g_simple_async_result_propagate_error (r, error);
 }
 
 /**
@@ -731,23 +790,26 @@ tracker_miner_execute_update (TrackerMiner               *miner,
  * @miner: a #TrackerMiner
  * @sparql: a SPARQL query
  * @cancellable: a #GCancellable to control the operation
- * @callback: a #TrackerMinerQueryCallback to call when the operation is finished
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished
  * @user_data: data to pass to @callback
  *
  * Executes the SPARQL query on tracker-store and returns asynchronously
  * the queried data. Use this whenever you need to get data from
  * already stored information.
  *
- * When the operation is finished, @callback will be called, providing the queried data,
- * or the error, if any. If the operation is cancelled, @callback will be called with the
- * error parameter filled in.
+ * When the operation is finished, @callback will be called, providing a #GAsyncResult
+ * object. Call tracker_miner_execute_sparql_finish on it to get the query results, or
+ * the GError object if an error occured.
+ *
+ * If the operation is cancelled, @callback will be called anyway, with the #GAsyncResult
+ * object containing an error.
  **/
 void
 tracker_miner_execute_sparql (TrackerMiner              *miner,
-			      const gchar               *sparql,
-			      GCancellable              *cancellable,
-			      TrackerMinerQueryCallback  callback,
-			      gpointer                   user_data)
+                              const gchar               *sparql,
+                              GCancellable              *cancellable,
+                              GAsyncReadyCallback        callback,
+                              gpointer                   user_data)
 {
 	TrackerMinerPrivate *priv;
 	AsyncCallData *data;
@@ -758,7 +820,7 @@ tracker_miner_execute_sparql (TrackerMiner              *miner,
 	g_return_if_fail (callback != NULL);
 
 	priv = TRACKER_MINER_GET_PRIVATE (miner);
-	data = async_call_data_new (miner, cancellable, callback, user_data, FALSE);
+	data = async_call_data_new (miner, cancellable, callback, user_data, tracker_miner_execute_sparql);
 
 	data->id = tracker_resources_sparql_query_async (miner->private->client,
 							 sparql, sparql_query_cb,
@@ -766,26 +828,54 @@ tracker_miner_execute_sparql (TrackerMiner              *miner,
 }
 
 /**
+ * tracker_miner_execute_sparql_finish:
+ * @miner: a #TrackerMiner
+ * @result: a #GAsyncResult object holding the result of the query
+ * @error: a #GError
+ *
+ * Finishes the async operation and returns the query results. If an error
+ * occured during the query, @error will be set.
+ *
+ **/
+GPtrArray*
+tracker_miner_execute_sparql_finish (TrackerMiner *miner,
+                                     GAsyncResult *result,
+                                     GError      **error)
+{
+	GSimpleAsyncResult *r = G_SIMPLE_ASYNC_RESULT (result);
+
+	if (g_simple_async_result_propagate_error (r, error)) {
+		return NULL;
+	}
+
+	return (GPtrArray*)g_simple_async_result_get_op_res_gpointer (r);
+}
+
+/**
  * tracker_miner_execute_batch_update:
  * @miner: a #TrackerMiner
  * @sparql: a set of SPARQL updates
  * @cancellable: a #GCancellable to control the operation
- * @callback: a #TrackerMinerUpdateCallback to call when the operation is finished
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished
  * @user_data: data to pass to @callback
  *
  * Executes a batch of update SPARQL queries on tracker-store, use this
  * whenever you want to perform data insertions or modifications in
  * batches.
  *
- * When the operation is finished, @callback will be called, providing the error, if any.
- * If the operation is cancelled, @callback will be called anyways, with error filled in.
+ * When the operation is finished, @callback will be called, providing a #GAsyncResult
+ * object. Call tracker_miner_execute_batch_update_finish on it to get the returned #GError,
+ * if there is one.
+ *
+ * If the operation is cancelled, @callback will be called anyway, with the #GAsyncResult
+ * object containing an error.
  **/
 void
 tracker_miner_execute_batch_update (TrackerMiner               *miner,
-				    const gchar                *sparql,
-				    GCancellable               *cancellable,
-				    TrackerMinerUpdateCallback  callback,
-				    gpointer                    user_data)
+                                    const gchar                *sparql,
+                                    GCancellable               *cancellable,
+                                    GAsyncReadyCallback         callback,
+                                    gpointer                    user_data)
 {
 	TrackerMinerPrivate *priv;
 	AsyncCallData *data;
@@ -795,7 +885,7 @@ tracker_miner_execute_batch_update (TrackerMiner               *miner,
 	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
 	priv = TRACKER_MINER_GET_PRIVATE (miner);
-	data = async_call_data_new (miner, cancellable, callback, user_data, TRUE);
+	data = async_call_data_new (miner, cancellable, callback, user_data, tracker_miner_execute_batch_update);
 
 	data->id = tracker_resources_batch_sparql_update_async (miner->private->client,
 								sparql, sparql_update_cb,
@@ -803,22 +893,47 @@ tracker_miner_execute_batch_update (TrackerMiner               *miner,
 }
 
 /**
+ * tracker_miner_execute_batch_update_finish:
+ * @miner: a #TrackerMiner
+ * @result: a #GAsyncResult
+ * @error: a #GError
+ *
+ * Finishes the async batch update operation. If an error occured during the update,
+ * @error will be set.
+ *
+ **/
+void
+tracker_miner_execute_batch_update_finish (TrackerMiner *miner,
+                                           GAsyncResult *result,
+                                           GError      **error)
+{
+	GSimpleAsyncResult *r = G_SIMPLE_ASYNC_RESULT (result);
+
+	g_simple_async_result_propagate_error (r, error);
+}
+
+/**
  * tracker_miner_commit:
  * @miner: a #TrackerMiner
  * @cancellable: a #GCancellable to control the operation
- * @callback: a #TrackerMinerUpdateCallback to call when the operation is finished
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished
  * @user_data: data to pass to @callback
  *
- * Commits all pending batch updates. see tracker_miner_execute_batch_update(). When
- * the operation is finished, @callback will be called, with the error parameter filled
- * in, if any. If the operation is cancelled through @cancellable, the callback will be
- * called anyways with error filled in.
+ * Commits all pending batch updates. See tracker_miner_execute_batch_update().
+ *
+ * When the operation is finished, @callback will be called, providing a #GAsyncResult
+ * object. Call tracker_miner_commit_finish on it to get the returned #GError,
+ * if there is one.
+ *
+ * If the operation is cancelled, @callback will be called anyway, with the #GAsyncResult
+ * object containing an error.
  **/
+
 void
 tracker_miner_commit (TrackerMiner               *miner,
-		      GCancellable               *cancellable,
-		      TrackerMinerUpdateCallback  callback,
-		      gpointer                    user_data)
+                      GCancellable               *cancellable,
+                      GAsyncReadyCallback         callback,
+                      gpointer                    user_data)
 
 {
 	TrackerMinerPrivate *priv;
@@ -828,13 +943,33 @@ tracker_miner_commit (TrackerMiner               *miner,
 	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
 	priv = TRACKER_MINER_GET_PRIVATE (miner);
-	data = async_call_data_new (miner, cancellable, callback, user_data, TRUE);
+	data = async_call_data_new (miner, cancellable, callback, user_data, tracker_miner_commit);
 
 	data->id = tracker_resources_batch_commit_async (miner->private->client,
 							 sparql_update_cb,
 							 data);
 }
 
+/**
+ * tracker_miner_commit_finish:
+ * @miner: a #TrackerMiner
+ * @result: a #GAsyncResult
+ * @error: a #GError
+ *
+ * Finishes the async comit operation. If an error occured during the commit,
+ * @error will be set.
+ *
+ **/
+void
+tracker_miner_commit_finish (TrackerMiner *miner,
+                             GAsyncResult *result,
+                             GError      **error)
+{
+	GSimpleAsyncResult *r = G_SIMPLE_ASYNC_RESULT (result);
+
+	g_simple_async_result_propagate_error (r, error);
+}
+
 static gint
 tracker_miner_pause_internal (TrackerMiner  *miner,
 			      const gchar   *application,
@@ -850,7 +985,7 @@ tracker_miner_pause_internal (TrackerMiner  *miner,
 	while (g_hash_table_iter_next (&iter, &key, &value)) {
 		PauseData *pd = value;
 
-		if (g_strcmp0 (application, pd->application) == 0 && 
+		if (g_strcmp0 (application, pd->application) == 0 &&
 		    g_strcmp0 (reason, pd->reason) == 0) {
 			/* Can't use duplicate pauses */
 			g_set_error_literal (error, TRACKER_MINER_ERROR, 0,
@@ -861,7 +996,7 @@ tracker_miner_pause_internal (TrackerMiner  *miner,
 
 	pd = pause_data_new (application, reason);
 
-	g_hash_table_insert (miner->private->pauses, 
+	g_hash_table_insert (miner->private->pauses,
 			     GINT_TO_POINTER (pd->cookie),
 			     pd);
 
@@ -917,7 +1052,7 @@ tracker_miner_pause (TrackerMiner  *miner,
  *
  * Returns: #TRUE if the cookie was valid.
  **/
-gboolean 
+gboolean
 tracker_miner_resume (TrackerMiner  *miner,
 		      gint           cookie,
 		      GError       **error)
@@ -1016,7 +1151,7 @@ tracker_miner_dbus_get_pause_details (TrackerMiner           *miner,
 
 	g_strfreev (applications_strv);
 	g_strfreev (reasons_strv);
-	
+
 	g_slist_free (applications);
 	g_slist_free (reasons);
 }
@@ -1075,7 +1210,7 @@ tracker_miner_dbus_resume (TrackerMiner           *miner,
 
 	tracker_dbus_async_return_if_fail (miner != NULL, context);
 
-	tracker_dbus_request_new (request_id, "%s(cookie:%d)", 
+	tracker_dbus_request_new (request_id, "%s(cookie:%d)",
 				  __PRETTY_FUNCTION__,
 				  cookie);
 
diff --git a/src/libtracker-miner/tracker-miner.h b/src/libtracker-miner/tracker-miner.h
index af046e4..648663e 100644
--- a/src/libtracker-miner/tracker-miner.h
+++ b/src/libtracker-miner/tracker-miner.h
@@ -83,14 +83,6 @@ typedef struct {
 			     GError       *error);
 } TrackerMinerClass;
 
-typedef void (* TrackerMinerUpdateCallback) (TrackerMiner *miner,
-					     const GError *error,
-					     gpointer      user_data);
-typedef void (* TrackerMinerQueryCallback)  (TrackerMiner *miner,
-					     GPtrArray    *result,
-					     const GError *error,
-					     gpointer      user_data);
-
 GType          tracker_miner_get_type       (void) G_GNUC_CONST;
 GQuark	       tracker_miner_error_quark    (void);
 
@@ -106,26 +98,44 @@ gboolean       tracker_miner_resume         (TrackerMiner  *miner,
 					     gint           cookie,
 					     GError       **error);
 
-void           tracker_miner_execute_update       (TrackerMiner               *miner,
-						   const gchar                *sparql,
-						   GCancellable               *cancellable,
-						   TrackerMinerUpdateCallback  callback,
-						   gpointer                    user_data);
-void           tracker_miner_execute_sparql       (TrackerMiner               *miner,
-						   const gchar                *sparql,
-						   GCancellable               *cancellable,
-						   TrackerMinerQueryCallback   callback,
-						   gpointer                    user_data);
-void           tracker_miner_execute_batch_update (TrackerMiner               *miner,
-						   const gchar                *sparql,
-						   GCancellable               *cancellable,
-						   TrackerMinerUpdateCallback  callback,
-						   gpointer                    user_data);
-void           tracker_miner_commit               (TrackerMiner               *miner,
-						   GCancellable               *cancellable,
-						   TrackerMinerUpdateCallback  callback,
-						   gpointer                    user_data);
-
+void           tracker_miner_execute_update              (TrackerMiner        *miner,
+                                                          const gchar         *sparql,
+                                                          GCancellable        *cancellable,
+                                                          GAsyncReadyCallback  callback,
+                                                          gpointer             user_data);
+
+void           tracker_miner_execute_update_finish       (TrackerMiner        *miner,
+                                                          GAsyncResult        *result,
+                                                          GError             **error);
+
+void           tracker_miner_execute_sparql              (TrackerMiner        *miner,
+                                                          const gchar         *sparql,
+                                                          GCancellable        *cancellable,
+                                                          GAsyncReadyCallback  callback,
+                                                          gpointer             user_data);
+
+GPtrArray*     tracker_miner_execute_sparql_finish       (TrackerMiner        *miner,
+                                                          GAsyncResult        *result,
+                                                          GError             **error);
+
+void           tracker_miner_execute_batch_update        (TrackerMiner        *miner,
+                                                          const gchar         *sparql,
+                                                          GCancellable        *cancellable,
+                                                          GAsyncReadyCallback  callback,
+                                                          gpointer             user_data);
+
+void           tracker_miner_execute_batch_update_finish (TrackerMiner        *miner,
+                                                          GAsyncResult        *result,
+                                                          GError             **error);
+
+void           tracker_miner_commit                      (TrackerMiner        *miner,
+                                                          GCancellable        *cancellable,
+                                                          GAsyncReadyCallback  callback,
+                                                          gpointer             user_data);
+
+void           tracker_miner_commit_finish       (TrackerMiner        *miner,
+                                                  GAsyncResult        *result,
+                                                  GError             **error);
 
 G_END_DECLS
 



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]