[tracker/g++-build-fixes] libtracker-miner: Fix builds including this library using g++
- From: Martyn James Russell <mr src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [tracker/g++-build-fixes] libtracker-miner: Fix builds including this library using g++
- Date: Tue, 24 May 2011 09:32:56 +0000 (UTC)
commit 332103f1c7ffe427b62e99196f72044f624236e6
Author: Martyn Russell <martyn lanedo com>
Date: Mon May 23 10:07:01 2011 +0100
libtracker-miner: Fix builds including this library using g++
src/libtracker-miner/tracker-crawler.c | 60 ++--
src/libtracker-miner/tracker-crawler.h | 2 +-
src/libtracker-miner/tracker-miner-fs.c | 620 +++++++++++++-------------
src/libtracker-miner/tracker-miner-fs.h | 2 +-
src/libtracker-miner/tracker-miner-object.c | 210 +++++-----
src/libtracker-miner/tracker-miner-object.h | 2 +-
src/libtracker-miner/tracker-miner-web.c | 10 +-
src/libtracker-miner/tracker-miner-web.h | 2 +-
src/libtracker-miner/tracker-monitor.c | 154 ++++----
src/libtracker-miner/tracker-monitor.h | 2 +-
10 files changed, 532 insertions(+), 532 deletions(-)
---
diff --git a/src/libtracker-miner/tracker-crawler.c b/src/libtracker-miner/tracker-crawler.c
index 274a645..d8f3ffc 100644
--- a/src/libtracker-miner/tracker-crawler.c
+++ b/src/libtracker-miner/tracker-crawler.c
@@ -202,9 +202,9 @@ tracker_crawler_init (TrackerCrawler *object)
{
TrackerCrawlerPrivate *priv;
- object->private = TRACKER_CRAWLER_GET_PRIVATE (object);
+ object->priv = TRACKER_CRAWLER_GET_PRIVATE (object);
- priv = object->private;
+ priv = object->priv;
priv->directories = g_queue_new ();
priv->cancellable = g_cancellable_new ();
@@ -424,7 +424,7 @@ process_func (gpointer data)
gboolean stop_idle = FALSE;
crawler = TRACKER_CRAWLER (data);
- priv = crawler->private;
+ priv = crawler->priv;
if (priv->is_paused) {
/* Stop the idle func for now until we are unpaused */
@@ -537,16 +537,16 @@ process_func (gpointer data)
static gboolean
process_func_start (TrackerCrawler *crawler)
{
- if (crawler->private->is_paused) {
+ if (crawler->priv->is_paused) {
return FALSE;
}
- if (crawler->private->is_finished) {
+ if (crawler->priv->is_finished) {
return FALSE;
}
- if (crawler->private->idle_id == 0) {
- crawler->private->idle_id = g_idle_add (process_func, crawler);
+ if (crawler->priv->idle_id == 0) {
+ crawler->priv->idle_id = g_idle_add (process_func, crawler);
}
return TRUE;
@@ -555,9 +555,9 @@ process_func_start (TrackerCrawler *crawler)
static void
process_func_stop (TrackerCrawler *crawler)
{
- if (crawler->private->idle_id != 0) {
- g_source_remove (crawler->private->idle_id);
- crawler->private->idle_id = 0;
+ if (crawler->priv->idle_id != 0) {
+ g_source_remove (crawler->priv->idle_id);
+ crawler->priv->idle_id = 0;
}
}
@@ -658,13 +658,13 @@ file_enumerate_next_cb (GObject *object,
ed = user_data;
crawler = ed->crawler;
- cancelled = g_cancellable_is_cancelled (crawler->private->cancellable);
+ cancelled = g_cancellable_is_cancelled (crawler->priv->cancellable);
files = g_file_enumerator_next_files_finish (enumerator,
result,
&error);
- if (error || !files || !crawler->private->is_running) {
+ if (error || !files || !crawler->priv->is_running) {
if (error && !cancelled) {
g_critical ("Could not crawl through directory: %s", error->message);
g_error_free (error);
@@ -724,7 +724,7 @@ file_enumerate_next (GFileEnumerator *enumerator,
g_file_enumerator_next_files_async (enumerator,
FILES_GROUP_SIZE,
G_PRIORITY_DEFAULT,
- ed->crawler->private->cancellable,
+ ed->crawler->priv->cancellable,
file_enumerate_next_cb,
ed);
}
@@ -744,7 +744,7 @@ file_enumerate_children_cb (GObject *file,
parent = G_FILE (file);
ed = (EnumeratorData*) user_data;
crawler = ed->crawler;
- cancelled = g_cancellable_is_cancelled (crawler->private->cancellable);
+ cancelled = g_cancellable_is_cancelled (crawler->priv->cancellable);
enumerator = g_file_enumerate_children_finish (parent, result, &error);
if (!enumerator) {
@@ -782,7 +782,7 @@ file_enumerate_children (TrackerCrawler *crawler,
FILE_ATTRIBUTES,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
G_PRIORITY_LOW,
- crawler->private->cancellable,
+ crawler->priv->cancellable,
file_enumerate_children_cb,
ed);
}
@@ -798,7 +798,7 @@ tracker_crawler_start (TrackerCrawler *crawler,
g_return_val_if_fail (TRACKER_IS_CRAWLER (crawler), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- priv = crawler->private;
+ priv = crawler->priv;
if (!g_file_query_exists (file, NULL)) {
return FALSE;
@@ -841,7 +841,7 @@ tracker_crawler_stop (TrackerCrawler *crawler)
g_return_if_fail (TRACKER_IS_CRAWLER (crawler));
- priv = crawler->private;
+ priv = crawler->priv;
/* If already not running, just ignore */
if (!priv->is_running) {
@@ -875,15 +875,15 @@ tracker_crawler_pause (TrackerCrawler *crawler)
{
g_return_if_fail (TRACKER_IS_CRAWLER (crawler));
- crawler->private->is_paused = TRUE;
+ crawler->priv->is_paused = TRUE;
- if (crawler->private->is_running) {
- g_timer_stop (crawler->private->timer);
+ if (crawler->priv->is_running) {
+ g_timer_stop (crawler->priv->timer);
process_func_stop (crawler);
}
g_message ("Crawler is paused, %s",
- crawler->private->is_running ? "currently running" : "not running");
+ crawler->priv->is_running ? "currently running" : "not running");
}
void
@@ -891,15 +891,15 @@ tracker_crawler_resume (TrackerCrawler *crawler)
{
g_return_if_fail (TRACKER_IS_CRAWLER (crawler));
- crawler->private->is_paused = FALSE;
+ crawler->priv->is_paused = FALSE;
- if (crawler->private->is_running) {
- g_timer_continue (crawler->private->timer);
+ if (crawler->priv->is_running) {
+ g_timer_continue (crawler->priv->timer);
process_func_start (crawler);
}
g_message ("Crawler is resuming, %s",
- crawler->private->is_running ? "currently running" : "not running");
+ crawler->priv->is_running ? "currently running" : "not running");
}
void
@@ -909,15 +909,15 @@ tracker_crawler_set_throttle (TrackerCrawler *crawler,
g_return_if_fail (TRACKER_IS_CRAWLER (crawler));
throttle = CLAMP (throttle, 0, 1);
- crawler->private->throttle = throttle;
+ crawler->priv->throttle = throttle;
/* Update timeouts */
- if (crawler->private->idle_id != 0) {
+ if (crawler->priv->idle_id != 0) {
guint interval, idle_id;
- interval = MAX_TIMEOUT_INTERVAL * crawler->private->throttle;
+ interval = MAX_TIMEOUT_INTERVAL * crawler->priv->throttle;
- g_source_remove (crawler->private->idle_id);
+ g_source_remove (crawler->priv->idle_id);
if (interval == 0) {
idle_id = g_idle_add (process_func, crawler);
@@ -925,6 +925,6 @@ tracker_crawler_set_throttle (TrackerCrawler *crawler,
idle_id = g_timeout_add (interval, process_func, crawler);
}
- crawler->private->idle_id = idle_id;
+ crawler->priv->idle_id = idle_id;
}
}
diff --git a/src/libtracker-miner/tracker-crawler.h b/src/libtracker-miner/tracker-crawler.h
index 6339a09..79781fc 100644
--- a/src/libtracker-miner/tracker-crawler.h
+++ b/src/libtracker-miner/tracker-crawler.h
@@ -45,7 +45,7 @@ typedef struct TrackerCrawlerPrivate TrackerCrawlerPrivate;
struct TrackerCrawler {
GObject parent;
- TrackerCrawlerPrivate *private;
+ TrackerCrawlerPrivate *priv;
};
struct TrackerCrawlerClass {
diff --git a/src/libtracker-miner/tracker-miner-fs.c b/src/libtracker-miner/tracker-miner-fs.c
index 1dd22c1..4a6e619 100644
--- a/src/libtracker-miner/tracker-miner-fs.c
+++ b/src/libtracker-miner/tracker-miner-fs.c
@@ -658,9 +658,9 @@ tracker_miner_fs_init (TrackerMinerFS *object)
{
TrackerMinerFSPrivate *priv;
- object->private = TRACKER_MINER_FS_GET_PRIVATE (object);
+ object->priv = TRACKER_MINER_FS_GET_PRIVATE (object);
- priv = object->private;
+ priv = object->priv;
priv->crawled_directories = g_queue_new ();
priv->items_created = g_queue_new ();
@@ -838,22 +838,22 @@ fs_set_property (GObject *object,
g_value_get_double (value));
break;
case PROP_WAIT_POOL_LIMIT:
- tracker_processing_pool_set_wait_limit (fs->private->processing_pool,
+ tracker_processing_pool_set_wait_limit (fs->priv->processing_pool,
g_value_get_uint (value));
break;
case PROP_READY_POOL_LIMIT:
- tracker_processing_pool_set_ready_limit (fs->private->processing_pool,
+ tracker_processing_pool_set_ready_limit (fs->priv->processing_pool,
g_value_get_uint (value));
break;
case PROP_N_REQUESTS_POOL_LIMIT:
- tracker_processing_pool_set_n_requests_limit (fs->private->processing_pool,
+ tracker_processing_pool_set_n_requests_limit (fs->priv->processing_pool,
g_value_get_uint (value));
break;
case PROP_MTIME_CHECKING:
- fs->private->mtime_checking = g_value_get_boolean (value);
+ fs->priv->mtime_checking = g_value_get_boolean (value);
break;
case PROP_INITIAL_CRAWLING:
- fs->private->initial_crawling = g_value_get_boolean (value);
+ fs->priv->initial_crawling = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -873,25 +873,25 @@ fs_get_property (GObject *object,
switch (prop_id) {
case PROP_THROTTLE:
- g_value_set_double (value, fs->private->throttle);
+ g_value_set_double (value, fs->priv->throttle);
break;
case PROP_WAIT_POOL_LIMIT:
g_value_set_uint (value,
- tracker_processing_pool_get_wait_limit (fs->private->processing_pool));
+ tracker_processing_pool_get_wait_limit (fs->priv->processing_pool));
break;
case PROP_READY_POOL_LIMIT:
g_value_set_uint (value,
- tracker_processing_pool_get_ready_limit (fs->private->processing_pool));
+ tracker_processing_pool_get_ready_limit (fs->priv->processing_pool));
break;
case PROP_N_REQUESTS_POOL_LIMIT:
g_value_set_uint (value,
- tracker_processing_pool_get_n_requests_limit (fs->private->processing_pool));
+ tracker_processing_pool_get_n_requests_limit (fs->priv->processing_pool));
break;
case PROP_MTIME_CHECKING:
- g_value_set_boolean (value, fs->private->mtime_checking);
+ g_value_set_boolean (value, fs->priv->mtime_checking);
break;
case PROP_INITIAL_CRAWLING:
- g_value_set_boolean (value, fs->private->initial_crawling);
+ g_value_set_boolean (value, fs->priv->initial_crawling);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -921,7 +921,7 @@ miner_started (TrackerMiner *miner)
fs = TRACKER_MINER_FS (miner);
- fs->private->been_started = TRUE;
+ fs->priv->been_started = TRUE;
tracker_info ("Initializing");
@@ -953,13 +953,13 @@ miner_paused (TrackerMiner *miner)
fs = TRACKER_MINER_FS (miner);
- fs->private->is_paused = TRUE;
+ fs->priv->is_paused = TRUE;
- tracker_crawler_pause (fs->private->crawler);
+ tracker_crawler_pause (fs->priv->crawler);
- if (fs->private->item_queues_handler_id) {
- g_source_remove (fs->private->item_queues_handler_id);
- fs->private->item_queues_handler_id = 0;
+ if (fs->priv->item_queues_handler_id) {
+ g_source_remove (fs->priv->item_queues_handler_id);
+ fs->priv->item_queues_handler_id = 0;
}
}
@@ -970,17 +970,17 @@ miner_resumed (TrackerMiner *miner)
fs = TRACKER_MINER_FS (miner);
- fs->private->is_paused = FALSE;
+ fs->priv->is_paused = FALSE;
- tracker_crawler_resume (fs->private->crawler);
+ tracker_crawler_resume (fs->priv->crawler);
/* Only set up queue handler if we have items waiting to be
* processed.
*/
- if (g_queue_get_length (fs->private->items_deleted) > 0 ||
- g_queue_get_length (fs->private->items_created) > 0 ||
- g_queue_get_length (fs->private->items_updated) > 0 ||
- g_queue_get_length (fs->private->items_moved) > 0) {
+ if (g_queue_get_length (fs->priv->items_deleted) > 0 ||
+ g_queue_get_length (fs->priv->items_created) > 0 ||
+ g_queue_get_length (fs->priv->items_updated) > 0 ||
+ g_queue_get_length (fs->priv->items_moved) > 0) {
item_queue_handlers_set_up (fs);
}
}
@@ -995,7 +995,7 @@ miner_ignore_next_update (TrackerMiner *miner, const GStrv urls)
fs = TRACKER_MINER_FS (miner);
for (n = 0; urls[n] != NULL; n++) {
- g_hash_table_insert (fs->private->items_ignore_next_update,
+ g_hash_table_insert (fs->priv->items_ignore_next_update,
g_strdup (urls[n]),
GINT_TO_POINTER (TRUE));
}
@@ -1048,22 +1048,22 @@ process_print_stats (TrackerMinerFS *fs)
* likely to be inaccurate. Devices can be added or removed so
* we can't assume stats are correct.
*/
- if (!fs->private->shown_totals) {
- fs->private->shown_totals = TRUE;
+ if (!fs->priv->shown_totals) {
+ fs->priv->shown_totals = TRUE;
tracker_info ("--------------------------------------------------");
tracker_info ("Total directories : %d (%d ignored)",
- fs->private->total_directories_found,
- fs->private->total_directories_ignored);
+ fs->priv->total_directories_found,
+ fs->priv->total_directories_ignored);
tracker_info ("Total files : %d (%d ignored)",
- fs->private->total_files_found,
- fs->private->total_files_ignored);
+ fs->priv->total_files_found,
+ fs->priv->total_files_ignored);
tracker_info ("Total monitors : %d",
- tracker_monitor_get_count (fs->private->monitor));
+ tracker_monitor_get_count (fs->priv->monitor));
tracker_info ("Total processed : %d (%d notified, %d with error)",
- fs->private->total_files_processed,
- fs->private->total_files_notified,
- fs->private->total_files_notified_error);
+ fs->priv->total_files_processed,
+ fs->priv->total_files_notified,
+ fs->priv->total_files_notified_error);
tracker_info ("--------------------------------------------------\n");
}
}
@@ -1083,23 +1083,23 @@ process_stop (TrackerMinerFS *fs)
NULL);
g_signal_emit (fs, signals[FINISHED], 0,
- fs->private->timer ? g_timer_elapsed (fs->private->timer, NULL) : 0.0,
- fs->private->total_directories_found,
- fs->private->total_directories_ignored,
- fs->private->total_files_found,
- fs->private->total_files_ignored);
+ fs->priv->timer ? g_timer_elapsed (fs->priv->timer, NULL) : 0.0,
+ fs->priv->total_directories_found,
+ fs->priv->total_directories_ignored,
+ fs->priv->total_files_found,
+ fs->priv->total_files_ignored);
- if (fs->private->timer) {
- g_timer_destroy (fs->private->timer);
- fs->private->timer = NULL;
+ if (fs->priv->timer) {
+ g_timer_destroy (fs->priv->timer);
+ fs->priv->timer = NULL;
}
- fs->private->total_directories_found = 0;
- fs->private->total_directories_ignored = 0;
- fs->private->total_files_found = 0;
- fs->private->total_files_ignored = 0;
+ fs->priv->total_directories_found = 0;
+ fs->priv->total_directories_ignored = 0;
+ fs->priv->total_files_found = 0;
+ fs->priv->total_files_ignored = 0;
- fs->private->been_crawled = TRUE;
+ fs->priv->been_crawled = TRUE;
}
static ItemMovedData *
@@ -1132,13 +1132,13 @@ processing_pool_task_finished_cb (TrackerProcessingTask *task,
TrackerMinerFSPrivate *priv;
fs = user_data;
- priv = fs->private;
+ priv = fs->priv;
if (error) {
g_critical ("Could not execute sparql: %s", error->message);
priv->total_files_notified_error++;
} else {
- if (fs->private->current_iri_cache_parent) {
+ if (fs->priv->current_iri_cache_parent) {
GFile *parent;
GFile *task_file;
@@ -1150,12 +1150,12 @@ processing_pool_task_finished_cb (TrackerProcessingTask *task,
parent = g_file_get_parent (task_file);
if (parent) {
- if (g_file_equal (parent, fs->private->current_iri_cache_parent) &&
- g_hash_table_lookup (fs->private->iri_cache, task_file) == NULL) {
+ if (g_file_equal (parent, fs->priv->current_iri_cache_parent) &&
+ g_hash_table_lookup (fs->priv->iri_cache, task_file) == NULL) {
/* Item is processed, add an empty element for the processed GFile,
* in case it is again processed before the cache expires
*/
- g_hash_table_insert (fs->private->iri_cache,
+ g_hash_table_insert (fs->priv->iri_cache,
g_object_ref (task_file),
NULL);
}
@@ -1327,7 +1327,7 @@ file_is_crawl_directory (TrackerMinerFS *fs,
GList *dirs;
/* Check whether file is a crawl directory itself */
- dirs = fs->private->config_directories;
+ dirs = fs->priv->config_directories;
while (dirs) {
DirectoryData *data;
@@ -1349,7 +1349,7 @@ find_config_directory (TrackerMinerFS *fs,
{
GList *dirs;
- dirs = fs->private->config_directories;
+ dirs = fs->priv->config_directories;
while (dirs) {
DirectoryData *data;
@@ -1376,7 +1376,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
GFile *parent;
guint cache_size;
- g_hash_table_remove_all (fs->private->iri_cache);
+ g_hash_table_remove_all (fs->priv->iri_cache);
/* Note: parent may be NULL if the file represents
* the root directory of the file system (applies to
@@ -1399,7 +1399,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
uri);
data.main_loop = g_main_loop_new (NULL, FALSE);
- data.values = g_hash_table_ref (fs->private->iri_cache);
+ data.values = g_hash_table_ref (fs->priv->iri_cache);
tracker_sparql_connection_query_async (tracker_miner_get_connection (TRACKER_MINER (fs)),
query,
@@ -1413,7 +1413,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
g_main_loop_unref (data.main_loop);
g_hash_table_unref (data.values);
- cache_size = g_hash_table_size (fs->private->iri_cache);
+ cache_size = g_hash_table_size (fs->priv->iri_cache);
if (cache_size == 0) {
if (file_is_crawl_directory (fs, file)) {
@@ -1433,7 +1433,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
/* Initialize data contents */
data.main_loop = g_main_loop_new (NULL, FALSE);
- data.values = g_hash_table_ref (fs->private->iri_cache);
+ data.values = g_hash_table_ref (fs->priv->iri_cache);
g_debug ("Generating children cache for URI '%s' (fn:starts-with)",
uri);
@@ -1462,7 +1462,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
* which are not direct children of this parent, but doesn't seem a big
* issue right now. In the best case, the dummy item that we created will
* be there with a proper mtime set. */
- cache_size = g_hash_table_size (fs->private->iri_cache);
+ cache_size = g_hash_table_size (fs->priv->iri_cache);
}
}
@@ -1472,7 +1472,7 @@ ensure_iri_cache (TrackerMinerFS *fs,
GHashTableIter iter;
gpointer key, value;
- g_hash_table_iter_init (&iter, fs->private->iri_cache);
+ g_hash_table_iter_init (&iter, fs->priv->iri_cache);
while (g_hash_table_iter_next (&iter, &key, &value)) {
gchar *fileuri;
@@ -1497,7 +1497,7 @@ iri_cache_lookup (TrackerMinerFS *fs,
gchar *query_iri;
/* Look for item in IRI cache */
- in_cache = g_hash_table_lookup_extended (fs->private->iri_cache,
+ in_cache = g_hash_table_lookup_extended (fs->priv->iri_cache,
file,
NULL,
&in_cache_value);
@@ -1517,7 +1517,7 @@ iri_cache_lookup (TrackerMinerFS *fs,
if (item_query_exists (fs, file, &query_iri, NULL)) {
/* Replace! as we may already have an item in the cache with
* NULL value! */
- g_hash_table_replace (fs->private->iri_cache,
+ g_hash_table_replace (fs->priv->iri_cache,
g_object_ref (file),
query_iri);
/* Set iri to return */
@@ -1526,7 +1526,7 @@ iri_cache_lookup (TrackerMinerFS *fs,
/* Not in store, remove item from cache if any */
if (in_cache)
- g_hash_table_remove (fs->private->iri_cache, file);
+ g_hash_table_remove (fs->priv->iri_cache, file);
return NULL;
}
@@ -1535,7 +1535,7 @@ static void
iri_cache_invalidate (TrackerMinerFS *fs,
GFile *file)
{
- g_hash_table_remove (fs->private->iri_cache, file);
+ g_hash_table_remove (fs->priv->iri_cache, file);
}
static UpdateProcessingTaskContext *
@@ -1594,7 +1594,7 @@ do_process_file (TrackerMinerFS *fs,
ctxt = tracker_processing_task_get_context (task);
task_file = tracker_processing_task_get_file (task);
uri = g_file_get_uri (task_file);
- priv = fs->private;
+ priv = fs->priv;
attribute_update_only = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (task_file),
priv->quark_attribute_updated));
@@ -1655,7 +1655,7 @@ item_add_or_update_cb (TrackerMinerFS *fs,
if (error) {
TrackerProcessingTask *first_item_task;
- first_item_task = tracker_processing_pool_get_last_wait (fs->private->processing_pool);
+ first_item_task = tracker_processing_pool_get_last_wait (fs->priv->processing_pool);
/* Perhaps this is too specific to TrackerMinerFiles, if the extractor
* is choking on some file, the miner will get a timeout for all files
@@ -1679,7 +1679,7 @@ item_add_or_update_cb (TrackerMinerFS *fs,
return;
} else {
- fs->private->total_files_notified_error++;
+ fs->priv->total_files_notified_error++;
g_message ("Could not process '%s': %s",
uri,
error->message ? error->message : "No error given");
@@ -1690,7 +1690,7 @@ item_add_or_update_cb (TrackerMinerFS *fs,
gboolean attribute_update_only;
attribute_update_only = GPOINTER_TO_INT (g_object_steal_qdata (G_OBJECT (task_file),
- fs->private->quark_attribute_updated));
+ fs->priv->quark_attribute_updated));
g_debug ("Updating item%s%s%s '%s' with urn '%s'%s",
error != NULL ? " (which had extractor error '" : "",
error != NULL ? (error->message ? error->message : "No error given") : "",
@@ -1744,7 +1744,7 @@ item_add_or_update_cb (TrackerMinerFS *fs,
/* If push_ready_task() returns FALSE, it means the actual db update was delayed,
* and in this case we need to setup queue handlers again */
- if (!tracker_processing_pool_push_ready_task (fs->private->processing_pool,
+ if (!tracker_processing_pool_push_ready_task (fs->priv->processing_pool,
task,
processing_pool_task_finished_cb,
fs)) {
@@ -1768,7 +1768,7 @@ item_add_or_update (TrackerMinerFS *fs,
const gchar *parent_urn = NULL;
UpdateProcessingTaskContext *ctxt;
- priv = fs->private;
+ priv = fs->priv;
retval = TRUE;
cancellable = g_cancellable_new ();
@@ -1778,32 +1778,32 @@ item_add_or_update (TrackerMinerFS *fs,
parent = g_file_get_parent (file);
if (parent) {
- if (!fs->private->current_iri_cache_parent ||
- !g_file_equal (parent, fs->private->current_iri_cache_parent)) {
+ if (!fs->priv->current_iri_cache_parent ||
+ !g_file_equal (parent, fs->priv->current_iri_cache_parent)) {
/* Cache the URN for the new current parent, processing
* order guarantees that all contents for a folder are
* inspected together, and that the parent folder info
* is already in tracker-store. So this should only
* happen on folder switch.
*/
- if (fs->private->current_iri_cache_parent)
- g_object_unref (fs->private->current_iri_cache_parent);
+ if (fs->priv->current_iri_cache_parent)
+ g_object_unref (fs->priv->current_iri_cache_parent);
- g_free (fs->private->current_iri_cache_parent_urn);
+ g_free (fs->priv->current_iri_cache_parent_urn);
- fs->private->current_iri_cache_parent = g_object_ref (parent);
+ fs->priv->current_iri_cache_parent = g_object_ref (parent);
if (!item_query_exists (fs,
parent,
- &fs->private->current_iri_cache_parent_urn,
+ &fs->priv->current_iri_cache_parent_urn,
NULL)) {
- fs->private->current_iri_cache_parent_urn = NULL;
+ fs->priv->current_iri_cache_parent_urn = NULL;
}
ensure_iri_cache (fs, file);
}
- parent_urn = fs->private->current_iri_cache_parent_urn;
+ parent_urn = fs->priv->current_iri_cache_parent_urn;
g_object_unref (parent);
}
@@ -1826,7 +1826,7 @@ item_add_or_update (TrackerMinerFS *fs,
tracker_processing_pool_push_wait_task (priv->processing_pool, task);
if (do_process_file (fs, task)) {
- fs->private->total_files_processed++;
+ fs->priv->total_files_processed++;
if (tracker_processing_pool_wait_limit_reached (priv->processing_pool)) {
retval = FALSE;
@@ -1884,7 +1884,7 @@ item_remove (TrackerMinerFS *fs,
/* If push_ready_task() returns FALSE, it means the actual db update was delayed,
* and in this case we need to setup queue handlers again */
- if (!tracker_processing_pool_push_ready_task (fs->private->processing_pool,
+ if (!tracker_processing_pool_push_ready_task (fs->priv->processing_pool,
task,
processing_pool_task_finished_cb,
fs)) {
@@ -1907,7 +1907,7 @@ item_remove (TrackerMinerFS *fs,
/* If push_ready_task() returns FALSE, it means the actual db update was delayed,
* and in this case we need to setup queue handlers again */
- if (!tracker_processing_pool_push_ready_task (fs->private->processing_pool,
+ if (!tracker_processing_pool_push_ready_task (fs->priv->processing_pool,
task,
processing_pool_task_finished_cb,
fs)) {
@@ -2001,7 +2001,7 @@ item_ignore_next_update (TrackerMinerFS *fs,
g_free (query);
}
- g_hash_table_remove (fs->private->items_ignore_next_update, uri);
+ g_hash_table_remove (fs->priv->items_ignore_next_update, uri);
g_object_unref (sparql);
g_object_unref (working_file);
@@ -2254,7 +2254,7 @@ item_move (TrackerMinerFS *fs,
g_string_free (sparql, FALSE));
/* If push_ready_task() returns FALSE, it means the actual db update was delayed,
* and in this case we need to setup queue handlers again */
- if (!tracker_processing_pool_push_ready_task (fs->private->processing_pool,
+ if (!tracker_processing_pool_push_ready_task (fs->priv->processing_pool,
task,
processing_pool_task_finished_cb,
fs)) {
@@ -2273,7 +2273,7 @@ static gboolean
check_ignore_next_update (TrackerMinerFS *fs, GFile *queue_file)
{
gchar *uri = g_file_get_uri (queue_file);
- if (g_hash_table_lookup (fs->private->items_ignore_next_update, uri)) {
+ if (g_hash_table_lookup (fs->priv->items_ignore_next_update, uri)) {
g_free (uri);
return TRUE;
}
@@ -2289,7 +2289,7 @@ fill_in_items_created_queue (TrackerMinerFS *fs)
GFile *file;
GNode *node;
- dir_data = g_queue_peek_head (fs->private->crawled_directories);
+ dir_data = g_queue_peek_head (fs->priv->crawled_directories);
if (g_queue_is_empty (dir_data->nodes)) {
/* Special case, append the root directory for the tree */
@@ -2299,9 +2299,9 @@ fill_in_items_created_queue (TrackerMinerFS *fs)
g_queue_push_tail (dir_data->nodes, node);
- if (!g_object_get_qdata (G_OBJECT (file), fs->private->quark_ignore_file)) {
+ if (!g_object_get_qdata (G_OBJECT (file), fs->priv->quark_ignore_file)) {
trace_eq_push_tail ("CREATED", file, "Root directory of tree");
- g_queue_push_tail (fs->private->items_created, g_object_ref (file));
+ g_queue_push_tail (fs->priv->items_created, g_object_ref (file));
return;
}
}
@@ -2329,9 +2329,9 @@ fill_in_items_created_queue (TrackerMinerFS *fs)
file = children->data;
dir_data->n_items_processed++;
- if (!g_object_get_qdata (G_OBJECT (file), fs->private->quark_ignore_file)) {
+ if (!g_object_get_qdata (G_OBJECT (file), fs->priv->quark_ignore_file)) {
trace_eq_push_tail ("CREATED", file, NULL);
- g_queue_push_tail (fs->private->items_created, g_object_ref (file));
+ g_queue_push_tail (fs->priv->items_created, g_object_ref (file));
}
if (children->children) {
@@ -2355,7 +2355,7 @@ fill_in_items_created_queue (TrackerMinerFS *fs)
if (g_queue_is_empty (dir_data->nodes)) {
/* There's no more data to process, move on to the next one */
- g_queue_pop_head (fs->private->crawled_directories);
+ g_queue_pop_head (fs->priv->crawled_directories);
crawled_directory_data_free (dir_data);
}
}
@@ -2368,7 +2368,7 @@ should_wait (TrackerMinerFS *fs,
GFile *parent;
/* Is the item already being processed? */
- if (tracker_processing_pool_find_task (fs->private->processing_pool,
+ if (tracker_processing_pool_find_task (fs->priv->processing_pool,
file,
TRUE)) {
/* Yes, a previous event on same item currently
@@ -2379,7 +2379,7 @@ should_wait (TrackerMinerFS *fs,
/* Is the item's parent being processed right now? */
parent = g_file_get_parent (file);
if (parent) {
- if (tracker_processing_pool_find_task (fs->private->processing_pool,
+ if (tracker_processing_pool_find_task (fs->priv->processing_pool,
parent,
TRUE)) {
/* Yes, a previous event on the parent of this item
@@ -2402,7 +2402,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
GFile *queue_file;
/* Deleted items first */
- queue_file = g_queue_pop_head (fs->private->items_deleted);
+ queue_file = g_queue_pop_head (fs->priv->items_deleted);
if (queue_file) {
*source_file = NULL;
@@ -2421,7 +2421,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
trace_eq_push_head ("DELETED", queue_file, "Should wait");
/* Need to postpone event... */
- g_queue_push_head (fs->private->items_deleted,
+ g_queue_push_head (fs->priv->items_deleted,
queue_file);
return QUEUE_WAIT;
}
@@ -2430,11 +2430,11 @@ item_queue_get_next_file (TrackerMinerFS *fs,
return QUEUE_DELETED;
}
- if (g_queue_is_empty (fs->private->items_created) &&
- !g_queue_is_empty (fs->private->crawled_directories)) {
+ if (g_queue_is_empty (fs->priv->items_created) &&
+ !g_queue_is_empty (fs->priv->crawled_directories)) {
trace_eq ("Created items queue empty, but still crawling (%d tasks in WAIT state)",
- tracker_processing_pool_get_wait_task_count (fs->private->processing_pool));
+ tracker_processing_pool_get_wait_task_count (fs->priv->processing_pool));
/* The items_created queue is empty, but there are pending
* items from the crawler to be processed. We feed the queue
@@ -2442,7 +2442,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
* info is inserted to the store before the children are
* inspected.
*/
- if (tracker_processing_pool_get_wait_task_count (fs->private->processing_pool) > 0) {
+ if (tracker_processing_pool_get_wait_task_count (fs->priv->processing_pool) > 0) {
/* Items still being processed */
*file = NULL;
*source_file = NULL;
@@ -2452,15 +2452,15 @@ item_queue_get_next_file (TrackerMinerFS *fs,
* one of these return something for the miner to do,
* or no data is left to process.
*/
- while (g_queue_is_empty (fs->private->items_created) &&
- !g_queue_is_empty (fs->private->crawled_directories)) {
+ while (g_queue_is_empty (fs->priv->items_created) &&
+ !g_queue_is_empty (fs->priv->crawled_directories)) {
fill_in_items_created_queue (fs);
}
}
}
/* Created items next */
- queue_file = g_queue_pop_head (fs->private->items_created);
+ queue_file = g_queue_pop_head (fs->priv->items_created);
if (queue_file) {
*source_file = NULL;
@@ -2480,7 +2480,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
uri = g_file_get_uri (queue_file);
g_debug ("Skipping the IgnoreNextUpdate request on CREATED event for '%s'",
uri);
- g_hash_table_remove (fs->private->items_ignore_next_update, uri);
+ g_hash_table_remove (fs->priv->items_ignore_next_update, uri);
g_free (uri);
}
@@ -2492,7 +2492,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
trace_eq_push_head ("CREATED", queue_file, "Should wait");
/* Need to postpone event... */
- g_queue_push_head (fs->private->items_created,
+ g_queue_push_head (fs->priv->items_created,
queue_file);
return QUEUE_WAIT;
}
@@ -2502,7 +2502,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
}
/* Updated items next */
- queue_file = g_queue_pop_head (fs->private->items_updated);
+ queue_file = g_queue_pop_head (fs->priv->items_updated);
if (queue_file) {
*file = queue_file;
*source_file = NULL;
@@ -2529,7 +2529,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
trace_eq_push_head ("UPDATED", queue_file, "Should wait");
/* Need to postpone event... */
- g_queue_push_head (fs->private->items_updated,
+ g_queue_push_head (fs->priv->items_updated,
queue_file);
return QUEUE_WAIT;
}
@@ -2538,7 +2538,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
}
/* Moved items next */
- data = g_queue_pop_head (fs->private->items_moved);
+ data = g_queue_pop_head (fs->priv->items_moved);
if (data) {
trace_eq_pop_head_2 ("MOVED", data->file, data->source_file);
@@ -2570,7 +2570,7 @@ item_queue_get_next_file (TrackerMinerFS *fs,
trace_eq_push_head_2 ("MOVED", data->source_file, data->file, "Should wait");
/* Need to postpone event... */
- g_queue_push_head (fs->private->items_moved,
+ g_queue_push_head (fs->priv->items_moved,
data); /* no need to create again */
return QUEUE_WAIT;
}
@@ -2602,17 +2602,17 @@ 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);
- items_to_process += g_queue_get_length (fs->private->items_moved);
+ items_to_process += g_queue_get_length (fs->priv->items_deleted);
+ items_to_process += g_queue_get_length (fs->priv->items_created);
+ items_to_process += g_queue_get_length (fs->priv->items_updated);
+ items_to_process += g_queue_get_length (fs->priv->items_moved);
- g_queue_foreach (fs->private->crawled_directories,
+ g_queue_foreach (fs->priv->crawled_directories,
(GFunc) get_tree_progress_foreach,
&items_to_process);
- items_total += fs->private->total_directories_found;
- items_total += fs->private->total_files_found;
+ items_total += fs->priv->total_directories_found;
+ items_total += fs->priv->total_files_found;
if (n_items_processed) {
*n_items_processed = ((items_total >= items_to_process) ?
@@ -2654,13 +2654,13 @@ item_queue_handlers_cb (gpointer user_data)
* the processing pool is cleared before starting with
* the next directories batch.
*/
- fs->private->item_queues_handler_id = 0;
+ fs->priv->item_queues_handler_id = 0;
/* We should flush the processing pool buffer here, because
* if there was a previous task on the same file we want to
* process now, we want it to get finished before we can go
* on with the queues... */
- tracker_processing_pool_buffer_flush (fs->private->processing_pool,
+ tracker_processing_pool_buffer_flush (fs->priv->processing_pool,
"Queue handlers WAIT");
return FALSE;
@@ -2686,8 +2686,8 @@ item_queue_handlers_cb (gpointer user_data)
return TRUE;
}
- if (!fs->private->timer) {
- fs->private->timer = g_timer_new ();
+ if (!fs->priv->timer) {
+ fs->priv->timer = g_timer_new ();
}
/* Update progress, but don't spam it. */
@@ -2706,9 +2706,9 @@ item_queue_handlers_cb (gpointer user_data)
progress_now = item_queue_get_progress (fs,
&items_processed,
&items_remaining);
- seconds_elapsed = g_timer_elapsed (fs->private->timer, NULL);
+ seconds_elapsed = g_timer_elapsed (fs->priv->timer, NULL);
- if (!fs->private->is_crawling) {
+ if (!fs->priv->is_crawling) {
gchar *status;
gint remaining_time;
@@ -2767,13 +2767,13 @@ item_queue_handlers_cb (gpointer user_data)
switch (queue) {
case QUEUE_NONE:
/* Print stats and signal finished */
- if (!fs->private->is_crawling &&
- tracker_processing_pool_get_total_task_count (fs->private->processing_pool) == 0) {
+ if (!fs->priv->is_crawling &&
+ tracker_processing_pool_get_total_task_count (fs->priv->processing_pool) == 0) {
process_stop (fs);
}
/* Flush any possible pending update here */
- tracker_processing_pool_buffer_flush (fs->private->processing_pool,
+ tracker_processing_pool_buffer_flush (fs->priv->processing_pool,
"Queue handlers NONE");
tracker_thumbnailer_send ();
@@ -2790,10 +2790,10 @@ item_queue_handlers_cb (gpointer user_data)
case QUEUE_CREATED:
/* Check existence before processing, if requested to do so. */
if (g_object_get_qdata (G_OBJECT (file),
- fs->private->quark_check_existence)) {
+ fs->priv->quark_check_existence)) {
/* Clear the qdata */
g_object_set_qdata (G_OBJECT (file),
- fs->private->quark_check_existence,
+ fs->priv->quark_check_existence,
GINT_TO_POINTER (FALSE));
/* Avoid adding items that already exist, when processing
@@ -2827,7 +2827,7 @@ item_queue_handlers_cb (gpointer user_data)
}
if (!keep_processing) {
- fs->private->item_queues_handler_id = 0;
+ fs->priv->item_queues_handler_id = 0;
return FALSE;
} else {
return TRUE;
@@ -2841,7 +2841,7 @@ _tracker_idle_add (TrackerMinerFS *fs,
{
guint interval;
- interval = MAX_TIMEOUT_INTERVAL * fs->private->throttle;
+ interval = MAX_TIMEOUT_INTERVAL * fs->priv->throttle;
if (interval == 0) {
return g_idle_add (func, user_data);
@@ -2853,16 +2853,16 @@ _tracker_idle_add (TrackerMinerFS *fs,
static void
item_queue_handlers_set_up (TrackerMinerFS *fs)
{
- if (fs->private->item_queues_handler_id != 0) {
+ if (fs->priv->item_queues_handler_id != 0) {
return;
}
- if (fs->private->is_paused) {
+ if (fs->priv->is_paused) {
return;
}
/* Already sent max number of tasks to tracker-extract? */
- if (tracker_processing_pool_wait_limit_reached (fs->private->processing_pool)) {
+ if (tracker_processing_pool_wait_limit_reached (fs->priv->processing_pool)) {
return;
}
@@ -2872,11 +2872,11 @@ item_queue_handlers_set_up (TrackerMinerFS *fs)
* very busy. Note that this is not very likely to happen, as the bottleneck
* during extraction is not the communication with tracker-store.
*/
- if (tracker_processing_pool_n_requests_limit_reached (fs->private->processing_pool)) {
+ if (tracker_processing_pool_n_requests_limit_reached (fs->priv->processing_pool)) {
return;
}
- if (!fs->private->is_crawling) {
+ if (!fs->priv->is_crawling) {
gchar *status;
g_object_get (fs, "status", &status, NULL);
@@ -2890,7 +2890,7 @@ item_queue_handlers_set_up (TrackerMinerFS *fs)
g_free (status);
}
- fs->private->item_queues_handler_id =
+ fs->priv->item_queues_handler_id =
_tracker_idle_add (fs,
item_queue_handlers_cb,
fs);
@@ -2913,7 +2913,7 @@ remove_unexisting_file_cb (gpointer key,
g_free (uri);
trace_eq_push_tail ("DELETED", file, "No longer exists");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -2926,7 +2926,7 @@ static void
check_if_files_removed (TrackerMinerFS *fs)
{
g_debug ("Checking if any file was removed...");
- g_hash_table_foreach_remove (fs->private->check_removed,
+ g_hash_table_foreach_remove (fs->priv->check_removed,
remove_unexisting_file_cb,
fs);
}
@@ -2941,7 +2941,7 @@ add_to_check_removed_cb (gpointer key,
/* Not adding any data to the value, we just want
* fast search for key availability */
- g_hash_table_insert (fs->private->check_removed,
+ g_hash_table_insert (fs->priv->check_removed,
g_object_ref (file),
NULL);
}
@@ -2955,8 +2955,8 @@ ensure_mtime_cache (TrackerMinerFS *fs,
GFile *parent;
guint cache_size;
- if (G_UNLIKELY (!fs->private->mtime_cache)) {
- fs->private->mtime_cache = g_hash_table_new_full (g_file_hash,
+ if (G_UNLIKELY (!fs->priv->mtime_cache)) {
+ fs->priv->mtime_cache = g_hash_table_new_full (g_file_hash,
(GEqualFunc) g_file_equal,
(GDestroyNotify) g_object_unref,
(GDestroyNotify) g_free);
@@ -2974,26 +2974,26 @@ ensure_mtime_cache (TrackerMinerFS *fs,
}
query = NULL;
- if (fs->private->current_mtime_cache_parent) {
+ if (fs->priv->current_mtime_cache_parent) {
if (parent &&
- g_file_equal (parent, fs->private->current_mtime_cache_parent)) {
+ g_file_equal (parent, fs->priv->current_mtime_cache_parent)) {
/* Cache is still valid */
g_object_unref (parent);
return;
}
- g_object_unref (fs->private->current_mtime_cache_parent);
+ g_object_unref (fs->priv->current_mtime_cache_parent);
}
- fs->private->current_mtime_cache_parent = parent;
+ fs->priv->current_mtime_cache_parent = parent;
- g_hash_table_remove_all (fs->private->mtime_cache);
+ g_hash_table_remove_all (fs->priv->mtime_cache);
/* Hack hack alert!
* Before querying the store, check if the parent directory is scheduled to
* be added, and if so, leave the mtime cache empty.
*/
- if (g_queue_find_custom (fs->private->items_created,
+ if (g_queue_find_custom (fs->priv->items_created,
parent,
(GCompareFunc)tracker_file_cmp) != NULL) {
uri = g_file_get_uri (file);
@@ -3038,7 +3038,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
/* Initialize data contents */
data.main_loop = g_main_loop_new (NULL, FALSE);
- data.values = g_hash_table_ref (fs->private->mtime_cache);
+ data.values = g_hash_table_ref (fs->priv->mtime_cache);
tracker_sparql_connection_query_async (tracker_miner_get_connection (TRACKER_MINER (fs)),
query,
@@ -3051,7 +3051,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
g_hash_table_unref (data.values);
}
- cache_size = g_hash_table_size (fs->private->mtime_cache);
+ cache_size = g_hash_table_size (fs->priv->mtime_cache);
/* Quite ugly hack: If mtime_cache is found EMPTY after the query, still, we
* may have a nfo:Folder where nfo:belogsToContainer was not yet set (when
@@ -3065,7 +3065,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
/* Initialize data contents */
data.main_loop = g_main_loop_new (NULL, FALSE);
- data.values = g_hash_table_ref (fs->private->mtime_cache);
+ data.values = g_hash_table_ref (fs->priv->mtime_cache);
uri = g_file_get_uri (parent);
g_debug ("Generating mtime cache for URI '%s' (fn:starts-with)", uri);
@@ -3095,7 +3095,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
* which are not direct children of this parent, but doesn't seem a big
* issue right now. In the best case, the dummy item that we created will
* be there with a proper mtime set. */
- cache_size = g_hash_table_size (fs->private->mtime_cache);
+ cache_size = g_hash_table_size (fs->priv->mtime_cache);
}
#ifdef MTIME_CACHE_ENABLE_TRACE
@@ -3104,7 +3104,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
GHashTableIter iter;
gpointer key, value;
- g_hash_table_iter_init (&iter, fs->private->mtime_cache);
+ g_hash_table_iter_init (&iter, fs->priv->mtime_cache);
while (g_hash_table_iter_next (&iter, &key, &value)) {
gchar *fileuri;
@@ -3116,7 +3116,7 @@ ensure_mtime_cache (TrackerMinerFS *fs,
#endif /* MTIME_CACHE_ENABLE_TRACE */
/* Iterate repopulated HT and add all to the check_removed HT */
- g_hash_table_foreach (fs->private->mtime_cache,
+ g_hash_table_foreach (fs->priv->mtime_cache,
add_to_check_removed_cb,
fs);
}
@@ -3137,13 +3137,13 @@ should_change_index_for_file (TrackerMinerFS *fs,
ensure_mtime_cache (fs, file, FALSE);
/* Remove the file from the list of files to be checked if removed */
- g_hash_table_remove (fs->private->check_removed, file);
+ g_hash_table_remove (fs->priv->check_removed, file);
/* If the file is NOT found in the cache, it means its a new
* file the store doesn't know about, so just report it to be
* re-indexed.
*/
- lookup_time = g_hash_table_lookup (fs->private->mtime_cache, file);
+ lookup_time = g_hash_table_lookup (fs->priv->mtime_cache, file);
if (!lookup_time) {
return TRUE;
}
@@ -3212,12 +3212,12 @@ should_process_file (TrackerMinerFS *fs,
if (!should_check_file (fs, file, is_dir)) {
ensure_mtime_cache (fs, file, FALSE);
- if (g_hash_table_lookup (fs->private->mtime_cache, file) != NULL) {
+ if (g_hash_table_lookup (fs->priv->mtime_cache, file) != NULL) {
/* File is told not to be checked, but exists
* in the store, put in deleted queue.
*/
trace_eq_push_tail ("DELETED", file, "No longer to be indexed");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
}
return FALSE;
@@ -3265,7 +3265,7 @@ check_item_queues (TrackerMinerFS *fs,
{
GList *elem;
- if (!fs->private->been_crawled) {
+ if (!fs->priv->been_crawled) {
/* Only do this after initial crawling, so
* we are mostly sure that we won't be doing
* checks on huge lists.
@@ -3282,24 +3282,24 @@ check_item_queues (TrackerMinerFS *fs,
return TRUE;
case QUEUE_UPDATED:
/* No further updates after a previous created/updated event */
- if (g_queue_find_custom (fs->private->items_created, file, compare_files) ||
- g_queue_find_custom (fs->private->items_updated, file, compare_files)) {
+ if (g_queue_find_custom (fs->priv->items_created, file, compare_files) ||
+ g_queue_find_custom (fs->priv->items_updated, file, compare_files)) {
g_debug (" Found previous unhandled CREATED/UPDATED event");
return FALSE;
}
return TRUE;
case QUEUE_DELETED:
- elem = g_queue_find_custom (fs->private->items_updated, file, compare_files);
+ elem = g_queue_find_custom (fs->priv->items_updated, file, compare_files);
if (elem) {
/* Remove all previous updates */
g_debug (" Deleting previous unhandled UPDATED event");
g_object_unref (elem->data);
- g_queue_delete_link (fs->private->items_updated, elem);
+ g_queue_delete_link (fs->priv->items_updated, elem);
}
- elem = g_queue_find_custom (fs->private->items_created, file, compare_files);
+ elem = g_queue_find_custom (fs->priv->items_created, file, compare_files);
if (elem) {
/* Created event still in the queue,
@@ -3307,31 +3307,31 @@ check_item_queues (TrackerMinerFS *fs,
*/
g_debug (" Found matching unhandled CREATED event, removing file altogether");
g_object_unref (elem->data);
- g_queue_delete_link (fs->private->items_created, elem);
+ g_queue_delete_link (fs->priv->items_created, elem);
return FALSE;
}
return TRUE;
case QUEUE_MOVED:
/* Kill any events on other_file (The dest one), since it will be rewritten anyway */
- elem = g_queue_find_custom (fs->private->items_created, other_file, compare_files);
+ elem = g_queue_find_custom (fs->priv->items_created, other_file, compare_files);
if (elem) {
g_debug (" Removing previous unhandled CREATED event for dest file, will be rewritten anyway");
g_object_unref (elem->data);
- g_queue_delete_link (fs->private->items_created, elem);
+ g_queue_delete_link (fs->priv->items_created, elem);
}
- elem = g_queue_find_custom (fs->private->items_updated, other_file, compare_files);
+ elem = g_queue_find_custom (fs->priv->items_updated, other_file, compare_files);
if (elem) {
g_debug (" Removing previous unhandled UPDATED event for dest file, will be rewritten anyway");
g_object_unref (elem->data);
- g_queue_delete_link (fs->private->items_updated, elem);
+ g_queue_delete_link (fs->priv->items_updated, elem);
}
/* Now check file (Origin one) */
- elem = g_queue_find_custom (fs->private->items_created, file, compare_files);
+ elem = g_queue_find_custom (fs->priv->items_created, file, compare_files);
if (elem) {
/* If source file was created, replace the
@@ -3347,7 +3347,7 @@ check_item_queues (TrackerMinerFS *fs,
return FALSE;
}
- elem = g_queue_find_custom (fs->private->items_moved, file, compare_moved_files);
+ elem = g_queue_find_custom (fs->priv->items_moved, file, compare_moved_files);
if (elem) {
ItemMovedData *data = elem->data;
@@ -3397,7 +3397,7 @@ monitor_item_created_cb (TrackerMonitor *monitor,
tracker_miner_fs_directory_add_internal (fs, file);
} else {
trace_eq_push_tail ("CREATED", file, "On monitor event");
- g_queue_push_tail (fs->private->items_created,
+ g_queue_push_tail (fs->priv->items_created,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -3430,7 +3430,7 @@ monitor_item_updated_cb (TrackerMonitor *monitor,
if (should_process &&
check_item_queues (fs, QUEUE_UPDATED, file, NULL)) {
trace_eq_push_tail ("UPDATED", file, "On monitor event");
- g_queue_push_tail (fs->private->items_updated,
+ g_queue_push_tail (fs->priv->items_updated,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -3464,11 +3464,11 @@ monitor_item_attribute_updated_cb (TrackerMonitor *monitor,
/* Set the Quark specifying that ONLY attributes were
* modified */
g_object_set_qdata (G_OBJECT (file),
- fs->private->quark_attribute_updated,
+ fs->priv->quark_attribute_updated,
GINT_TO_POINTER (TRUE));
trace_eq_push_tail ("UPDATED", file, "On monitor event (attributes)");
- g_queue_push_tail (fs->private->items_updated,
+ g_queue_push_tail (fs->priv->items_updated,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -3500,7 +3500,7 @@ monitor_item_deleted_cb (TrackerMonitor *monitor,
if (should_process &&
check_item_queues (fs, QUEUE_DELETED, file, NULL)) {
trace_eq_push_tail ("DELETED", file, "On monitor event");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -3512,7 +3512,7 @@ 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,
+ l = g_list_find_custom (fs->priv->directories,
path,
(GCompareFunc) g_strcmp0);
@@ -3520,10 +3520,10 @@ monitor_item_deleted_cb (TrackerMonitor *monitor,
* processing, this is because we do this same clean up later
* in process_device_next()
*/
- if (l && l != fs->private->current_directory) {
+ if (l && l != fs->priv->current_directory) {
directory_data_unref (l->data);
- fs->private->directories =
- g_list_delete_link (fs->private->directories, l);
+ fs->priv->directories =
+ g_list_delete_link (fs->priv->directories, l);
}
#endif
@@ -3545,7 +3545,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
if (!is_source_monitored) {
if (is_directory) {
/* Remove monitors if any */
- tracker_monitor_remove_recursively (fs->private->monitor,
+ tracker_monitor_remove_recursively (fs->priv->monitor,
file);
if (should_recurse_for_directory (fs, other_file)) {
gchar *uri;
@@ -3587,7 +3587,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
if (!source_stored) {
/* Remove monitors if any */
if (is_directory) {
- tracker_monitor_remove_recursively (fs->private->monitor,
+ tracker_monitor_remove_recursively (fs->priv->monitor,
file);
}
@@ -3596,7 +3596,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
if (!is_directory ||
!should_recurse_for_directory (fs, other_file)) {
trace_eq_push_tail ("CREATED", other_file, "On move monitor event");
- g_queue_push_tail (fs->private->items_created,
+ g_queue_push_tail (fs->priv->items_created,
g_object_ref (other_file));
item_queue_handlers_set_up (fs);
@@ -3608,21 +3608,21 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
} else if (!should_process_other) {
/* Remove monitors if any */
if (is_directory) {
- tracker_monitor_remove_recursively (fs->private->monitor,
+ tracker_monitor_remove_recursively (fs->priv->monitor,
file);
}
/* Delete old file */
if (check_item_queues (fs, QUEUE_DELETED, file, NULL)) {
trace_eq_push_tail ("DELETED", file, "On move monitor event");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
item_queue_handlers_set_up (fs);
}
} else {
/* Move monitors to the new place */
if (is_directory) {
- tracker_monitor_move (fs->private->monitor,
+ tracker_monitor_move (fs->priv->monitor,
file,
other_file);
}
@@ -3630,7 +3630,7 @@ monitor_item_moved_cb (TrackerMonitor *monitor,
/* Move old file to new file */
if (check_item_queues (fs, QUEUE_MOVED, file, other_file)) {
trace_eq_push_tail_2 ("MOVED", file, other_file, "On monitor event");
- g_queue_push_tail (fs->private->items_moved,
+ g_queue_push_tail (fs->priv->items_moved,
item_moved_data_new (other_file, file));
item_queue_handlers_set_up (fs);
}
@@ -3648,9 +3648,9 @@ crawler_check_file_cb (TrackerCrawler *crawler,
{
TrackerMinerFS *fs = user_data;
- if (!fs->private->been_crawled &&
- (!fs->private->mtime_checking ||
- !fs->private->initial_crawling)) {
+ if (!fs->priv->been_crawled &&
+ (!fs->priv->mtime_checking ||
+ !fs->priv->initial_crawling)) {
return FALSE;
}
@@ -3669,25 +3669,25 @@ crawler_check_directory_cb (TrackerCrawler *crawler,
if (!should_check) {
/* Remove monitors if any */
- tracker_monitor_remove (fs->private->monitor, file);
+ tracker_monitor_remove (fs->priv->monitor, file);
/* Put item in deleted queue if it existed in the store */
ensure_mtime_cache (fs, file, FALSE);
- if (g_hash_table_lookup (fs->private->mtime_cache, file) != NULL) {
+ if (g_hash_table_lookup (fs->priv->mtime_cache, file) != NULL) {
/* File is told not to be checked, but exists
* in the store, put in deleted queue.
*/
trace_eq_push_tail ("DELETED", file, "while crawling directory");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
}
} else {
gboolean should_change_index;
- if (!fs->private->been_crawled &&
- (!fs->private->mtime_checking ||
- !fs->private->initial_crawling)) {
+ if (!fs->priv->been_crawled &&
+ (!fs->priv->mtime_checking ||
+ !fs->priv->initial_crawling)) {
should_change_index = FALSE;
} else {
should_change_index = should_change_index_for_file (fs, file);
@@ -3699,7 +3699,7 @@ crawler_check_directory_cb (TrackerCrawler *crawler,
* actually changed, hence this flag.
*/
g_object_set_qdata (G_OBJECT (file),
- fs->private->quark_ignore_file,
+ fs->priv->quark_ignore_file,
GINT_TO_POINTER (TRUE));
}
}
@@ -3750,31 +3750,31 @@ crawler_check_directory_contents_cb (TrackerCrawler *crawler,
* -First crawl has already been done OR
* -mtime_checking is TRUE.
*/
- if (fs->private->been_crawled || fs->private->mtime_checking) {
+ if (fs->priv->been_crawled || fs->priv->mtime_checking) {
/* Set quark so that before trying to add the item we first
* check for its existence. */
g_object_set_qdata (G_OBJECT (parent),
- fs->private->quark_check_existence,
+ fs->priv->quark_check_existence,
GINT_TO_POINTER (TRUE));
/* Before adding the monitor, start notifying the store
* about the new directory, so that if any file event comes
* afterwards, the directory is already in store. */
trace_eq_push_tail ("CREATED", parent, "while crawling directory, parent");
- g_queue_push_tail (fs->private->items_created,
+ g_queue_push_tail (fs->priv->items_created,
g_object_ref (parent));
item_queue_handlers_set_up (fs);
/* As we already added here, specify that it shouldn't be added
* any more */
g_object_set_qdata (G_OBJECT (parent),
- fs->private->quark_ignore_file,
+ fs->priv->quark_ignore_file,
GINT_TO_POINTER (TRUE));
}
- tracker_monitor_add (fs->private->monitor, parent);
+ tracker_monitor_add (fs->priv->monitor, parent);
} else {
- tracker_monitor_remove (fs->private->monitor, parent);
+ tracker_monitor_remove (fs->priv->monitor, parent);
}
return process;
@@ -3867,18 +3867,18 @@ crawler_directory_crawled_cb (TrackerCrawler *crawler,
* further data is left there.
*/
dir_data = crawled_directory_data_new (tree);
- g_queue_push_tail (fs->private->crawled_directories, dir_data);
+ g_queue_push_tail (fs->priv->crawled_directories, dir_data);
/* Update stats */
- fs->private->directories_found += directories_found;
- fs->private->directories_ignored += directories_ignored;
- fs->private->files_found += files_found;
- fs->private->files_ignored += files_ignored;
+ fs->priv->directories_found += directories_found;
+ fs->priv->directories_ignored += directories_ignored;
+ fs->priv->files_found += files_found;
+ fs->priv->files_ignored += files_ignored;
- fs->private->total_directories_found += directories_found;
- fs->private->total_directories_ignored += directories_ignored;
- fs->private->total_files_found += files_found;
- fs->private->total_files_ignored += files_ignored;
+ fs->priv->total_directories_found += directories_found;
+ fs->priv->total_directories_ignored += directories_ignored;
+ fs->priv->total_files_found += files_found;
+ fs->priv->total_files_ignored += files_ignored;
g_message (" Found %d directories, ignored %d directories",
directories_found,
@@ -3895,14 +3895,14 @@ crawler_finished_cb (TrackerCrawler *crawler,
{
TrackerMinerFS *fs = user_data;
- fs->private->is_crawling = FALSE;
+ fs->priv->is_crawling = FALSE;
tracker_info ("%s crawling files after %2.2f seconds",
was_interrupted ? "Stopped" : "Finished",
- g_timer_elapsed (fs->private->timer, NULL));
+ g_timer_elapsed (fs->priv->timer, NULL));
- directory_data_unref (fs->private->current_directory);
- fs->private->current_directory = NULL;
+ directory_data_unref (fs->priv->current_directory);
+ fs->priv->current_directory = NULL;
if (!was_interrupted) {
/* Check if any file was left after whole crawling */
@@ -3911,7 +3911,7 @@ crawler_finished_cb (TrackerCrawler *crawler,
/* Ditch files to check for removal, as the crawler was
* interrupted, it can lead to false positives.
*/
- g_hash_table_remove_all (fs->private->check_removed);
+ g_hash_table_remove_all (fs->priv->check_removed);
}
/* Proceed to next thing to process */
@@ -3925,46 +3925,46 @@ crawl_directories_cb (gpointer user_data)
gchar *path, *path_utf8;
gchar *str;
- if (fs->private->current_directory) {
+ if (fs->priv->current_directory) {
g_critical ("One directory is already being processed, bailing out");
- fs->private->crawl_directories_id = 0;
+ fs->priv->crawl_directories_id = 0;
return FALSE;
}
- if (!fs->private->directories) {
- if (fs->private->current_iri_cache_parent) {
+ if (!fs->priv->directories) {
+ if (fs->priv->current_iri_cache_parent) {
/* Unset parent folder so caches are regenerated */
- g_object_unref (fs->private->current_iri_cache_parent);
- fs->private->current_iri_cache_parent = NULL;
+ g_object_unref (fs->priv->current_iri_cache_parent);
+ fs->priv->current_iri_cache_parent = NULL;
}
- if (fs->private->current_mtime_cache_parent) {
+ if (fs->priv->current_mtime_cache_parent) {
/* Unset parent folder so caches are regenerated */
- g_object_unref (fs->private->current_mtime_cache_parent);
- fs->private->current_mtime_cache_parent = NULL;
+ g_object_unref (fs->priv->current_mtime_cache_parent);
+ fs->priv->current_mtime_cache_parent = NULL;
}
/* Now we handle the queue */
item_queue_handlers_set_up (fs);
crawl_directories_stop (fs);
- fs->private->crawl_directories_id = 0;
+ fs->priv->crawl_directories_id = 0;
return FALSE;
}
- if (!fs->private->timer) {
- fs->private->timer = g_timer_new ();
+ if (!fs->priv->timer) {
+ fs->priv->timer = g_timer_new ();
}
- fs->private->current_directory = fs->private->directories->data;
- fs->private->directories = g_list_remove (fs->private->directories,
- fs->private->current_directory);
+ fs->priv->current_directory = fs->priv->directories->data;
+ fs->priv->directories = g_list_remove (fs->priv->directories,
+ fs->priv->current_directory);
- path = g_file_get_path (fs->private->current_directory->file);
+ path = g_file_get_path (fs->priv->current_directory->file);
path_utf8 = g_filename_to_utf8 (path, -1, NULL, NULL, NULL);
g_free (path);
- if (fs->private->current_directory->recurse) {
+ if (fs->priv->current_directory->recurse) {
str = g_strdup_printf ("Crawling recursively directory '%s'", path_utf8);
} else {
str = g_strdup_printf ("Crawling single directory '%s'", path_utf8);
@@ -3983,18 +3983,18 @@ crawl_directories_cb (gpointer user_data)
NULL);
g_free (str);
- if (tracker_crawler_start (fs->private->crawler,
- fs->private->current_directory->file,
- fs->private->current_directory->recurse)) {
+ if (tracker_crawler_start (fs->priv->crawler,
+ fs->priv->current_directory->file,
+ fs->priv->current_directory->recurse)) {
/* Crawler when restart the idle function when done */
- fs->private->is_crawling = TRUE;
- fs->private->crawl_directories_id = 0;
+ fs->priv->is_crawling = TRUE;
+ fs->priv->crawl_directories_id = 0;
return FALSE;
}
/* Directory couldn't be processed */
- directory_data_unref (fs->private->current_directory);
- fs->private->current_directory = NULL;
+ directory_data_unref (fs->priv->current_directory);
+ fs->priv->current_directory = NULL;
return TRUE;
}
@@ -4002,55 +4002,55 @@ crawl_directories_cb (gpointer user_data)
static void
crawl_directories_start (TrackerMinerFS *fs)
{
- if (!fs->private->initial_crawling) {
+ if (!fs->priv->initial_crawling) {
/* Do not perform initial crawling */
g_message ("Crawling is disabled, waiting for DBus events");
process_stop (fs);
return;
}
- if (fs->private->crawl_directories_id != 0 ||
- fs->private->current_directory) {
+ if (fs->priv->crawl_directories_id != 0 ||
+ fs->priv->current_directory) {
/* Processing ALREADY going on */
return;
}
- if (!fs->private->been_started) {
+ if (!fs->priv->been_started) {
/* Miner has not been started yet */
return;
}
- if (!fs->private->timer) {
- fs->private->timer = g_timer_new ();
+ if (!fs->priv->timer) {
+ fs->priv->timer = g_timer_new ();
}
- fs->private->directories_found = 0;
- fs->private->directories_ignored = 0;
- fs->private->files_found = 0;
- fs->private->files_ignored = 0;
+ fs->priv->directories_found = 0;
+ fs->priv->directories_ignored = 0;
+ fs->priv->files_found = 0;
+ fs->priv->files_ignored = 0;
- fs->private->crawl_directories_id = _tracker_idle_add (fs, crawl_directories_cb, fs);
+ fs->priv->crawl_directories_id = _tracker_idle_add (fs, crawl_directories_cb, fs);
}
static void
crawl_directories_stop (TrackerMinerFS *fs)
{
- if (fs->private->crawl_directories_id == 0) {
+ if (fs->priv->crawl_directories_id == 0) {
/* No processing going on, nothing to stop */
return;
}
- if (fs->private->current_directory) {
- tracker_crawler_stop (fs->private->crawler);
+ if (fs->priv->current_directory) {
+ tracker_crawler_stop (fs->priv->crawler);
}
/* Is this the right time to emit FINISHED? What about
* monitor events left to handle? Should they matter
* here?
*/
- if (fs->private->crawl_directories_id != 0) {
- g_source_remove (fs->private->crawl_directories_id);
- fs->private->crawl_directories_id = 0;
+ if (fs->priv->crawl_directories_id != 0) {
+ g_source_remove (fs->priv->crawl_directories_id);
+ fs->priv->crawl_directories_id = 0;
}
}
@@ -4061,7 +4061,7 @@ should_recurse_for_directory (TrackerMinerFS *fs,
gboolean recurse = FALSE;
GList *dirs;
- for (dirs = fs->private->config_directories; dirs; dirs = dirs->next) {
+ for (dirs = fs->priv->config_directories; dirs; dirs = dirs->next) {
DirectoryData *data;
data = dirs->data;
@@ -4110,11 +4110,11 @@ tracker_miner_fs_directory_add_internal (TrackerMinerFS *fs,
data = directory_data_new (file, recurse);
/* Only add if not already there */
- if (!g_list_find_custom (fs->private->directories,
+ if (!g_list_find_custom (fs->priv->directories,
data,
directory_compare_cb)) {
- fs->private->directories =
- g_list_append (fs->private->directories,
+ fs->priv->directories =
+ g_list_append (fs->priv->directories,
directory_data_ref (data));
crawl_directories_start (fs);
@@ -4146,20 +4146,20 @@ tracker_miner_fs_directory_add (TrackerMinerFS *fs,
dir_data = directory_data_new (file, recurse);
/* New directory to add in config_directories? */
- if (!g_list_find_custom (fs->private->config_directories,
+ if (!g_list_find_custom (fs->priv->config_directories,
dir_data,
directory_compare_cb)) {
- fs->private->config_directories =
- g_list_append (fs->private->config_directories,
+ fs->priv->config_directories =
+ g_list_append (fs->priv->config_directories,
directory_data_ref (dir_data));
}
/* If not already in the list to process, add it */
- if (!g_list_find_custom (fs->private->directories,
+ if (!g_list_find_custom (fs->priv->directories,
dir_data,
directory_compare_cb)) {
- fs->private->directories =
- g_list_append (fs->private->directories,
+ fs->priv->directories =
+ g_list_append (fs->priv->directories,
directory_data_ref (dir_data));
crawl_directories_start (fs);
@@ -4235,7 +4235,7 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
g_return_val_if_fail (TRACKER_IS_MINER_FS (fs), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- priv = fs->private;
+ priv = fs->priv;
timer = g_timer_new ();
g_debug ("Removing directory");
@@ -4246,20 +4246,20 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
g_debug (" Cancelled processing pool tasks at %f\n", g_timer_elapsed (timer, NULL));
- if (fs->private->current_directory) {
+ if (fs->priv->current_directory) {
GFile *current_file;
- current_file = fs->private->current_directory->file;
+ current_file = fs->priv->current_directory->file;
if (g_file_equal (file, current_file) ||
g_file_has_prefix (file, current_file)) {
/* Dir is being processed currently, cancel crawler */
- tracker_crawler_stop (fs->private->crawler);
+ tracker_crawler_stop (fs->priv->crawler);
return_val = TRUE;
}
}
- dirs = fs->private->directories;
+ dirs = fs->priv->directories;
while (dirs) {
DirectoryData *data = dirs->data;
@@ -4270,12 +4270,12 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
if (g_file_equal (file, data->file) ||
g_file_has_prefix (file, data->file)) {
directory_data_unref (data);
- fs->private->directories = g_list_delete_link (fs->private->directories, link);
+ fs->priv->directories = g_list_delete_link (fs->priv->directories, link);
return_val = TRUE;
}
}
- dirs = fs->private->config_directories;
+ dirs = fs->priv->config_directories;
while (dirs) {
DirectoryData *data = dirs->data;
@@ -4285,12 +4285,12 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
if (g_file_equal (file, data->file)) {
directory_data_unref (data);
- fs->private->config_directories = g_list_delete_link (fs->private->config_directories, link);
+ fs->priv->config_directories = g_list_delete_link (fs->priv->config_directories, link);
return_val = TRUE;
}
}
- dirs = fs->private->crawled_directories->head;
+ dirs = fs->priv->crawled_directories->head;
while (dirs) {
CrawledDirectoryData *data = dirs->data;
@@ -4315,7 +4315,7 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
g_debug (" Removed files at %f\n", g_timer_elapsed (timer, NULL));
/* Remove all monitors */
- tracker_monitor_remove_recursively (fs->private->monitor, file);
+ tracker_monitor_remove_recursively (fs->priv->monitor, file);
g_message ("Finished remove directory operation in %f\n", g_timer_elapsed (timer, NULL));
g_timer_destroy (timer);
@@ -4349,7 +4349,7 @@ tracker_miner_fs_directory_remove_full (TrackerMinerFS *fs,
/* And remove all info about the directory (recursively)
* from the store... */
trace_eq_push_tail ("DELETED", file, "on remove full");
- g_queue_push_tail (fs->private->items_deleted,
+ g_queue_push_tail (fs->priv->items_deleted,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -4393,7 +4393,7 @@ check_file_parents (TrackerMinerFS *fs,
for (p = parents; p; p = p->next) {
trace_eq_push_tail ("UPDATED", p->data, "checking file parents");
- g_queue_push_tail (fs->private->items_updated, p->data);
+ g_queue_push_tail (fs->priv->items_updated, p->data);
}
g_list_free (parents);
@@ -4440,7 +4440,7 @@ tracker_miner_fs_check_file (TrackerMinerFS *fs,
}
trace_eq_push_tail ("UPDATED", file, "Requested by application");
- g_queue_push_tail (fs->private->items_updated,
+ g_queue_push_tail (fs->priv->items_updated,
g_object_ref (file));
item_queue_handlers_set_up (fs);
@@ -4515,9 +4515,9 @@ tracker_miner_fs_file_notify (TrackerMinerFS *fs,
g_return_if_fail (TRACKER_IS_MINER_FS (fs));
g_return_if_fail (G_IS_FILE (file));
- fs->private->total_files_notified++;
+ fs->priv->total_files_notified++;
- task = tracker_processing_pool_find_task (fs->private->processing_pool,
+ task = tracker_processing_pool_find_task (fs->priv->processing_pool,
file,
FALSE);
@@ -4560,26 +4560,26 @@ tracker_miner_fs_set_throttle (TrackerMinerFS *fs,
throttle = CLAMP (throttle, 0, 1);
- if (fs->private->throttle == throttle) {
+ if (fs->priv->throttle == throttle) {
return;
}
- fs->private->throttle = throttle;
+ fs->priv->throttle = throttle;
/* Update timeouts */
- if (fs->private->item_queues_handler_id != 0) {
- g_source_remove (fs->private->item_queues_handler_id);
+ if (fs->priv->item_queues_handler_id != 0) {
+ g_source_remove (fs->priv->item_queues_handler_id);
- fs->private->item_queues_handler_id =
+ fs->priv->item_queues_handler_id =
_tracker_idle_add (fs,
item_queue_handlers_cb,
fs);
}
- if (fs->private->crawl_directories_id) {
- g_source_remove (fs->private->crawl_directories_id);
+ if (fs->priv->crawl_directories_id) {
+ g_source_remove (fs->priv->crawl_directories_id);
- fs->private->crawl_directories_id =
+ fs->priv->crawl_directories_id =
_tracker_idle_add (fs, crawl_directories_cb, fs);
}
}
@@ -4599,7 +4599,7 @@ tracker_miner_fs_get_throttle (TrackerMinerFS *fs)
{
g_return_val_if_fail (TRACKER_IS_MINER_FS (fs), 0);
- return fs->private->throttle;
+ return fs->priv->throttle;
}
/**
@@ -4628,7 +4628,7 @@ tracker_miner_fs_get_urn (TrackerMinerFS *fs,
g_return_val_if_fail (G_IS_FILE (file), NULL);
/* Check if found in currently processed data */
- task = tracker_processing_pool_find_task (fs->private->processing_pool,
+ task = tracker_processing_pool_find_task (fs->priv->processing_pool,
file,
FALSE);
@@ -4720,7 +4720,7 @@ tracker_miner_fs_get_parent_urn (TrackerMinerFS *fs,
g_return_val_if_fail (G_IS_FILE (file), NULL);
/* Check if found in currently processed data */
- task = tracker_processing_pool_find_task (fs->private->processing_pool,
+ task = tracker_processing_pool_find_task (fs->priv->processing_pool,
file,
FALSE);
@@ -4764,10 +4764,10 @@ tracker_miner_fs_force_recheck (TrackerMinerFS *fs)
g_message ("Forcing re-check on all index directories");
- directories = g_list_copy (fs->private->config_directories);
+ directories = g_list_copy (fs->priv->config_directories);
g_list_foreach (directories, (GFunc) directory_data_ref, NULL);
- fs->private->directories = g_list_concat (fs->private->directories, directories);
+ fs->priv->directories = g_list_concat (fs->priv->directories, directories);
crawl_directories_start (fs);
}
@@ -4801,7 +4801,7 @@ tracker_miner_fs_set_mtime_checking (TrackerMinerFS *fs,
{
g_return_if_fail (TRACKER_IS_MINER_FS (fs));
- fs->private->mtime_checking = mtime_checking;
+ fs->priv->mtime_checking = mtime_checking;
}
/**
@@ -4818,7 +4818,7 @@ tracker_miner_fs_get_mtime_checking (TrackerMinerFS *fs)
{
g_return_val_if_fail (TRACKER_IS_MINER_FS (fs), FALSE);
- return fs->private->mtime_checking;
+ return fs->priv->mtime_checking;
}
void
@@ -4827,7 +4827,7 @@ tracker_miner_fs_set_initial_crawling (TrackerMinerFS *fs,
{
g_return_if_fail (TRACKER_IS_MINER_FS (fs));
- fs->private->initial_crawling = do_initial_crawling;
+ fs->priv->initial_crawling = do_initial_crawling;
}
gboolean
@@ -4835,7 +4835,7 @@ tracker_miner_fs_get_initial_crawling (TrackerMinerFS *fs)
{
g_return_val_if_fail (TRACKER_IS_MINER_FS (fs), FALSE);
- return fs->private->initial_crawling;
+ return fs->priv->initial_crawling;
}
/**
@@ -4852,10 +4852,10 @@ tracker_miner_fs_has_items_to_process (TrackerMinerFS *fs)
{
g_return_val_if_fail (TRACKER_IS_MINER_FS (fs), FALSE);
- if (g_queue_get_length (fs->private->items_deleted) > 0 ||
- g_queue_get_length (fs->private->items_created) > 0 ||
- g_queue_get_length (fs->private->items_updated) > 0 ||
- g_queue_get_length (fs->private->items_moved) > 0) {
+ if (g_queue_get_length (fs->priv->items_deleted) > 0 ||
+ g_queue_get_length (fs->priv->items_created) > 0 ||
+ g_queue_get_length (fs->priv->items_updated) > 0 ||
+ g_queue_get_length (fs->priv->items_moved) > 0) {
return TRUE;
}
@@ -4891,7 +4891,7 @@ tracker_miner_fs_add_directory_without_parent (TrackerMinerFS *fs,
return;
}
- for (l = fs->private->dirs_without_parent;
+ for (l = fs->priv->dirs_without_parent;
l;
l = g_list_next (l)) {
if (g_file_equal (l->data, parent)) {
@@ -4902,7 +4902,7 @@ tracker_miner_fs_add_directory_without_parent (TrackerMinerFS *fs,
}
/* We add the parent of the input file */
- fs->private->dirs_without_parent = g_list_prepend (fs->private->dirs_without_parent,
+ fs->priv->dirs_without_parent = g_list_prepend (fs->priv->dirs_without_parent,
parent);
}
@@ -4914,7 +4914,7 @@ miner_fs_has_children_without_parent (TrackerMinerFS *fs,
{
GList *l;
- for (l = fs->private->dirs_without_parent;
+ for (l = fs->priv->dirs_without_parent;
l;
l = g_list_next (l)) {
if (g_file_equal (l->data, file)) {
@@ -4986,10 +4986,10 @@ miner_fs_queues_status_trace_timeout_cb (gpointer data)
TrackerMinerFS *fs = data;
trace_eq ("(%s) ------------", G_OBJECT_TYPE_NAME (fs));
- miner_fs_trace_queue_with_files (fs, "CREATED", fs->private->items_created);
- miner_fs_trace_queue_with_files (fs, "UPDATED", fs->private->items_updated);
- miner_fs_trace_queue_with_files (fs, "DELETED", fs->private->items_deleted);
- miner_fs_trace_queue_with_data (fs, "MOVED", fs->private->items_moved);
+ miner_fs_trace_queue_with_files (fs, "CREATED", fs->priv->items_created);
+ miner_fs_trace_queue_with_files (fs, "UPDATED", fs->priv->items_updated);
+ miner_fs_trace_queue_with_files (fs, "DELETED", fs->priv->items_deleted);
+ miner_fs_trace_queue_with_data (fs, "MOVED", fs->priv->items_moved);
return TRUE;
}
diff --git a/src/libtracker-miner/tracker-miner-fs.h b/src/libtracker-miner/tracker-miner-fs.h
index e26c71f..f5f1b7c 100644
--- a/src/libtracker-miner/tracker-miner-fs.h
+++ b/src/libtracker-miner/tracker-miner-fs.h
@@ -52,7 +52,7 @@ typedef struct _TrackerMinerFSPrivate TrackerMinerFSPrivate;
**/
struct _TrackerMinerFS {
TrackerMiner parent;
- TrackerMinerFSPrivate *private;
+ TrackerMinerFSPrivate *priv;
};
/**
diff --git a/src/libtracker-miner/tracker-miner-object.c b/src/libtracker-miner/tracker-miner-object.c
index 3d70ac5..e56d55e 100644
--- a/src/libtracker-miner/tracker-miner-object.c
+++ b/src/libtracker-miner/tracker-miner-object.c
@@ -387,28 +387,28 @@ miner_initable_init (GInitable *initable,
};
/* Try to get SPARQL connection... */
- miner->private->connection = tracker_sparql_connection_get (NULL, &inner_error);
- if (!miner->private->connection) {
+ miner->priv->connection = tracker_sparql_connection_get (NULL, &inner_error);
+ if (!miner->priv->connection) {
g_propagate_error (error, inner_error);
return FALSE;
}
/* Try to get DBus connection... */
- miner->private->d_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &inner_error);
- if (!miner->private->d_connection) {
+ miner->priv->d_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &inner_error);
+ if (!miner->priv->d_connection) {
g_propagate_error (error, inner_error);
return FALSE;
}
/* Setup introspection data */
- miner->private->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &inner_error);
- if (!miner->private->introspection_data) {
+ miner->priv->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &inner_error);
+ if (!miner->priv->introspection_data) {
g_propagate_error (error, inner_error);
return FALSE;
}
/* Check miner has a proper name */
- if (!miner->private->name) {
+ if (!miner->priv->name) {
g_set_error (error,
TRACKER_MINER_ERROR,
0,
@@ -418,23 +418,23 @@ miner_initable_init (GInitable *initable,
}
/* Setup full name */
- miner->private->full_name = g_strconcat (TRACKER_MINER_DBUS_NAME_PREFIX,
- miner->private->name,
+ miner->priv->full_name = g_strconcat (TRACKER_MINER_DBUS_NAME_PREFIX,
+ miner->priv->name,
NULL);
/* Register the D-Bus object */
- miner->private->full_path = g_strconcat (TRACKER_MINER_DBUS_PATH_PREFIX,
- miner->private->name,
+ miner->priv->full_path = g_strconcat (TRACKER_MINER_DBUS_PATH_PREFIX,
+ miner->priv->name,
NULL);
g_message ("Registering D-Bus object...");
- g_message (" Path:'%s'", miner->private->full_path);
+ g_message (" Path:'%s'", miner->priv->full_path);
g_message (" Object Type:'%s'", G_OBJECT_TYPE_NAME (miner));
- miner->private->registration_id =
- g_dbus_connection_register_object (miner->private->d_connection,
- miner->private->full_path,
- miner->private->introspection_data->interfaces[0],
+ miner->priv->registration_id =
+ g_dbus_connection_register_object (miner->priv->d_connection,
+ miner->priv->full_path,
+ miner->priv->introspection_data->interfaces[0],
&interface_vtable,
miner,
NULL,
@@ -443,18 +443,18 @@ miner_initable_init (GInitable *initable,
g_propagate_error (error, inner_error);
g_prefix_error (error,
"Could not register the D-Bus object '%s'. ",
- miner->private->full_path);
+ miner->priv->full_path);
return FALSE;
}
/* Request the D-Bus name */
- reply = g_dbus_connection_call_sync (miner->private->d_connection,
+ reply = g_dbus_connection_call_sync (miner->priv->d_connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"RequestName",
g_variant_new ("(su)",
- miner->private->full_name,
+ miner->priv->full_name,
0x4 /* DBUS_NAME_FLAG_DO_NOT_QUEUE */),
G_VARIANT_TYPE ("(u)"),
0, -1, NULL, &inner_error);
@@ -462,7 +462,7 @@ miner_initable_init (GInitable *initable,
g_propagate_error (error, inner_error);
g_prefix_error (error,
"Could not acquire name:'%s'. ",
- miner->private->full_name);
+ miner->priv->full_name);
return FALSE;
}
@@ -475,11 +475,11 @@ miner_initable_init (GInitable *initable,
0,
"D-Bus service name:'%s' is already taken, "
"perhaps the application is already running?",
- miner->private->full_name);
+ miner->priv->full_name);
return FALSE;
}
- miner->private->watch_name_id = g_bus_watch_name (G_BUS_TYPE_SESSION,
+ miner->priv->watch_name_id = g_bus_watch_name (G_BUS_TYPE_SESSION,
TRACKER_SERVICE,
G_BUS_NAME_WATCHER_FLAGS_NONE,
on_tracker_store_appeared,
@@ -494,7 +494,7 @@ static void
tracker_miner_init (TrackerMiner *miner)
{
TrackerMinerPrivate *priv;
- miner->private = priv = TRACKER_MINER_GET_PRIVATE (miner);
+ miner->priv = priv = TRACKER_MINER_GET_PRIVATE (miner);
priv->pauses = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
@@ -506,20 +506,20 @@ static void
miner_update_progress (TrackerMiner *miner)
{
g_signal_emit (miner, signals[PROGRESS], 0,
- miner->private->status,
- miner->private->progress,
- miner->private->remaining_time);
+ miner->priv->status,
+ miner->priv->progress,
+ miner->priv->remaining_time);
- if (miner->private->d_connection) {
- g_dbus_connection_emit_signal (miner->private->d_connection,
+ if (miner->priv->d_connection) {
+ g_dbus_connection_emit_signal (miner->priv->d_connection,
NULL,
- miner->private->full_path,
+ miner->priv->full_path,
TRACKER_MINER_DBUS_INTERFACE,
"Progress",
g_variant_new ("(sdi)",
- miner->private->status,
- miner->private->progress,
- miner->private->remaining_time),
+ miner->priv->status,
+ miner->priv->progress,
+ miner->priv->remaining_time),
NULL);
}
}
@@ -534,21 +534,21 @@ miner_set_property (GObject *object,
switch (prop_id) {
case PROP_NAME:
- g_free (miner->private->name);
- miner->private->name = g_value_dup_string (value);
+ g_free (miner->priv->name);
+ miner->priv->name = g_value_dup_string (value);
break;
case PROP_STATUS: {
const gchar *new_status;
new_status = g_value_get_string (value);
- if (miner->private->status && new_status &&
- strcmp (miner->private->status, new_status) == 0) {
+ if (miner->priv->status && new_status &&
+ strcmp (miner->priv->status, new_status) == 0) {
/* Same, do nothing */
break;
}
- g_free (miner->private->status);
- miner->private->status = g_strdup (new_status);
+ g_free (miner->priv->status);
+ miner->priv->status = g_strdup (new_status);
miner_update_progress (miner);
break;
}
@@ -563,12 +563,12 @@ miner_set_property (GObject *object,
*
* Only notify 1% changes
*/
- if (new_progress == miner->private->progress) {
+ if (new_progress == miner->priv->progress) {
/* Same, do nothing */
break;
}
- miner->private->progress = new_progress;
+ miner->priv->progress = new_progress;
miner_update_progress (miner);
break;
}
@@ -576,9 +576,9 @@ miner_set_property (GObject *object,
gint new_remaining_time;
new_remaining_time = g_value_get_int (value);
- if (new_remaining_time != miner->private->remaining_time) {
+ if (new_remaining_time != miner->priv->remaining_time) {
/* Just set the new remaining time, don't notify it */
- miner->private->remaining_time = new_remaining_time;
+ miner->priv->remaining_time = new_remaining_time;
}
break;
}
@@ -598,16 +598,16 @@ miner_get_property (GObject *object,
switch (prop_id) {
case PROP_NAME:
- g_value_set_string (value, miner->private->name);
+ g_value_set_string (value, miner->priv->name);
break;
case PROP_STATUS:
- g_value_set_string (value, miner->private->status);
+ g_value_set_string (value, miner->priv->status);
break;
case PROP_PROGRESS:
- g_value_set_double (value, miner->private->progress);
+ g_value_set_double (value, miner->priv->progress);
break;
case PROP_REMAINING_TIME:
- g_value_set_int (value, miner->private->remaining_time);
+ g_value_set_int (value, miner->priv->remaining_time);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -671,16 +671,16 @@ void
tracker_miner_start (TrackerMiner *miner)
{
g_return_if_fail (TRACKER_IS_MINER (miner));
- g_return_if_fail (miner->private->started == FALSE);
+ g_return_if_fail (miner->priv->started == FALSE);
- miner->private->started = TRUE;
+ miner->priv->started = TRUE;
g_signal_emit (miner, signals[STARTED], 0);
- if (miner->private->d_connection) {
- g_dbus_connection_emit_signal (miner->private->d_connection,
+ if (miner->priv->d_connection) {
+ g_dbus_connection_emit_signal (miner->priv->d_connection,
NULL,
- miner->private->full_path,
+ miner->priv->full_path,
TRACKER_MINER_DBUS_INTERFACE,
"Started",
NULL,
@@ -700,16 +700,16 @@ void
tracker_miner_stop (TrackerMiner *miner)
{
g_return_if_fail (TRACKER_IS_MINER (miner));
- g_return_if_fail (miner->private->started == TRUE);
+ g_return_if_fail (miner->priv->started == TRUE);
- miner->private->started = FALSE;
+ miner->priv->started = FALSE;
g_signal_emit (miner, signals[STOPPED], 0);
- if (miner->private->d_connection) {
- g_dbus_connection_emit_signal (miner->private->d_connection,
+ if (miner->priv->d_connection) {
+ g_dbus_connection_emit_signal (miner->priv->d_connection,
NULL,
- miner->private->full_path,
+ miner->priv->full_path,
TRACKER_MINER_DBUS_INTERFACE,
"Stopped",
NULL,
@@ -750,7 +750,7 @@ tracker_miner_is_started (TrackerMiner *miner)
{
g_return_val_if_fail (TRACKER_IS_MINER (miner), TRUE);
- return miner->private->started;
+ return miner->priv->started;
}
/**
@@ -768,7 +768,7 @@ tracker_miner_is_paused (TrackerMiner *miner)
{
g_return_val_if_fail (TRACKER_IS_MINER (miner), TRUE);
- return g_hash_table_size (miner->private->pauses) > 0 ? TRUE : FALSE;
+ return g_hash_table_size (miner->priv->pauses) > 0 ? TRUE : FALSE;
}
/**
@@ -787,7 +787,7 @@ tracker_miner_get_n_pause_reasons (TrackerMiner *miner)
{
g_return_val_if_fail (TRACKER_IS_MINER (miner), 0);
- return g_hash_table_size (miner->private->pauses);
+ return g_hash_table_size (miner->priv->pauses);
}
static gint
@@ -801,7 +801,7 @@ tracker_miner_pause_internal (TrackerMiner *miner,
gpointer key, value;
/* Check this is not a duplicate pause */
- g_hash_table_iter_init (&iter, miner->private->pauses);
+ g_hash_table_iter_init (&iter, miner->priv->pauses);
while (g_hash_table_iter_next (&iter, &key, &value)) {
PauseData *pd = value;
@@ -816,19 +816,19 @@ tracker_miner_pause_internal (TrackerMiner *miner,
pd = pause_data_new (application, reason);
- g_hash_table_insert (miner->private->pauses,
+ g_hash_table_insert (miner->priv->pauses,
GINT_TO_POINTER (pd->cookie),
pd);
- if (g_hash_table_size (miner->private->pauses) == 1) {
+ if (g_hash_table_size (miner->priv->pauses) == 1) {
/* Pause */
- g_message ("Miner:'%s' is pausing", miner->private->name);
+ g_message ("Miner:'%s' is pausing", miner->priv->name);
g_signal_emit (miner, signals[PAUSED], 0);
- if (miner->private->d_connection) {
- g_dbus_connection_emit_signal (miner->private->d_connection,
+ if (miner->priv->d_connection) {
+ g_dbus_connection_emit_signal (miner->priv->d_connection,
NULL,
- miner->private->full_path,
+ miner->priv->full_path,
TRACKER_MINER_DBUS_INTERFACE,
"Paused",
NULL,
@@ -866,7 +866,7 @@ tracker_miner_pause (TrackerMiner *miner,
application = g_get_application_name ();
if (!application) {
- application = miner->private->name;
+ application = miner->priv->name;
}
return tracker_miner_pause_internal (miner, application, reason, error);
@@ -893,21 +893,21 @@ tracker_miner_resume (TrackerMiner *miner,
{
g_return_val_if_fail (TRACKER_IS_MINER (miner), FALSE);
- if (!g_hash_table_remove (miner->private->pauses, GINT_TO_POINTER (cookie))) {
+ if (!g_hash_table_remove (miner->priv->pauses, GINT_TO_POINTER (cookie))) {
g_set_error_literal (error, TRACKER_MINER_ERROR, 0,
_("Cookie not recognized to resume paused miner"));
return FALSE;
}
- if (g_hash_table_size (miner->private->pauses) == 0) {
+ if (g_hash_table_size (miner->priv->pauses) == 0) {
/* Resume */
- g_message ("Miner:'%s' is resuming", miner->private->name);
+ g_message ("Miner:'%s' is resuming", miner->priv->name);
g_signal_emit (miner, signals[RESUMED], 0);
- if (miner->private->d_connection) {
- g_dbus_connection_emit_signal (miner->private->d_connection,
+ if (miner->priv->d_connection) {
+ g_dbus_connection_emit_signal (miner->priv->d_connection,
NULL,
- miner->private->full_path,
+ miner->priv->full_path,
TRACKER_MINER_DBUS_INTERFACE,
"Resumed",
NULL,
@@ -931,7 +931,7 @@ tracker_miner_resume (TrackerMiner *miner,
TrackerSparqlConnection *
tracker_miner_get_connection (TrackerMiner *miner)
{
- return miner->private->connection;
+ return miner->priv->connection;
}
/**
@@ -947,7 +947,7 @@ tracker_miner_get_connection (TrackerMiner *miner)
GDBusConnection *
tracker_miner_get_dbus_connection (TrackerMiner *miner)
{
- return miner->private->d_connection;
+ return miner->priv->d_connection;
}
/**
@@ -963,7 +963,7 @@ tracker_miner_get_dbus_connection (TrackerMiner *miner)
G_CONST_RETURN gchar *
tracker_miner_get_dbus_full_name (TrackerMiner *miner)
{
- return miner->private->full_name;
+ return miner->priv->full_name;
}
/**
@@ -979,7 +979,7 @@ tracker_miner_get_dbus_full_name (TrackerMiner *miner)
G_CONST_RETURN gchar *
tracker_miner_get_dbus_full_path (TrackerMiner *miner)
{
- return miner->private->full_path;
+ return miner->priv->full_path;
}
static void
@@ -987,34 +987,34 @@ miner_finalize (GObject *object)
{
TrackerMiner *miner = TRACKER_MINER (object);
- if (miner->private->watch_name_id != 0) {
- g_bus_unwatch_name (miner->private->watch_name_id);
+ if (miner->priv->watch_name_id != 0) {
+ g_bus_unwatch_name (miner->priv->watch_name_id);
}
- if (miner->private->registration_id != 0) {
- g_dbus_connection_unregister_object (miner->private->d_connection,
- miner->private->registration_id);
+ if (miner->priv->registration_id != 0) {
+ g_dbus_connection_unregister_object (miner->priv->d_connection,
+ miner->priv->registration_id);
}
- if (miner->private->introspection_data) {
- g_dbus_node_info_unref (miner->private->introspection_data);
+ if (miner->priv->introspection_data) {
+ g_dbus_node_info_unref (miner->priv->introspection_data);
}
- if (miner->private->d_connection) {
- g_object_unref (miner->private->d_connection);
+ if (miner->priv->d_connection) {
+ g_object_unref (miner->priv->d_connection);
}
- g_free (miner->private->status);
- g_free (miner->private->name);
- g_free (miner->private->full_name);
- g_free (miner->private->full_path);
+ g_free (miner->priv->status);
+ g_free (miner->priv->name);
+ g_free (miner->priv->full_name);
+ g_free (miner->priv->full_path);
- if (miner->private->connection) {
- g_object_unref (miner->private->connection);
+ if (miner->priv->connection) {
+ g_object_unref (miner->priv->connection);
}
- if (miner->private->pauses) {
- g_hash_table_unref (miner->private->pauses);
+ if (miner->priv->pauses) {
+ g_hash_table_unref (miner->priv->pauses);
}
G_OBJECT_CLASS (tracker_miner_parent_class)->finalize (object);
@@ -1121,7 +1121,7 @@ handle_method_call_get_pause_details (TrackerMiner *miner,
applications = NULL;
reasons = NULL;
- g_hash_table_iter_init (&iter, miner->private->pauses);
+ g_hash_table_iter_init (&iter, miner->priv->pauses);
while (g_hash_table_iter_next (&iter, &key, &value)) {
PauseData *pd = value;
@@ -1157,7 +1157,7 @@ handle_method_call_get_remaining_time (TrackerMiner *miner,
tracker_dbus_request_end (request, NULL);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(i)",
- miner->private->remaining_time));
+ miner->priv->remaining_time));
}
static void
@@ -1172,7 +1172,7 @@ handle_method_call_get_progress (TrackerMiner *miner,
tracker_dbus_request_end (request, NULL);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(d)",
- miner->private->progress));
+ miner->priv->progress));
}
static void
@@ -1187,7 +1187,7 @@ handle_method_call_get_status (TrackerMiner *miner,
tracker_dbus_request_end (request, NULL);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(s)",
- miner->private->status ? miner->private->status : ""));
+ miner->priv->status ? miner->priv->status : ""));
}
@@ -1267,13 +1267,13 @@ on_tracker_store_appeared (GDBusConnection *connection,
TrackerMiner *miner = user_data;
g_debug ("Miner:'%s' noticed store availability has changed to AVAILABLE",
- miner->private->name);
+ miner->priv->name);
- if (miner->private->availability_cookie != 0) {
+ if (miner->priv->availability_cookie != 0) {
GError *error = NULL;
tracker_miner_resume (miner,
- miner->private->availability_cookie,
+ miner->priv->availability_cookie,
&error);
if (error) {
@@ -1281,7 +1281,7 @@ on_tracker_store_appeared (GDBusConnection *connection,
g_error_free (error);
}
- miner->private->availability_cookie = 0;
+ miner->priv->availability_cookie = 0;
}
}
@@ -1293,9 +1293,9 @@ on_tracker_store_disappeared (GDBusConnection *connection,
TrackerMiner *miner = user_data;
g_debug ("Miner:'%s' noticed store availability has changed to UNAVAILABLE",
- miner->private->name);
+ miner->priv->name);
- if (miner->private->availability_cookie == 0) {
+ if (miner->priv->availability_cookie == 0) {
GError *error = NULL;
gint cookie_id;
@@ -1307,7 +1307,7 @@ on_tracker_store_disappeared (GDBusConnection *connection,
g_warning ("Could not pause, %s", error->message);
g_error_free (error);
} else {
- miner->private->availability_cookie = cookie_id;
+ miner->priv->availability_cookie = cookie_id;
}
}
}
diff --git a/src/libtracker-miner/tracker-miner-object.h b/src/libtracker-miner/tracker-miner-object.h
index 5602360..e9d9e91 100644
--- a/src/libtracker-miner/tracker-miner-object.h
+++ b/src/libtracker-miner/tracker-miner-object.h
@@ -51,7 +51,7 @@ typedef struct _TrackerMinerPrivate TrackerMinerPrivate;
**/
struct _TrackerMiner {
GObject parent_instance;
- TrackerMinerPrivate *private;
+ TrackerMinerPrivate *priv;
};
/**
diff --git a/src/libtracker-miner/tracker-miner-web.c b/src/libtracker-miner/tracker-miner-web.c
index 41f18d7..c3fc657 100644
--- a/src/libtracker-miner/tracker-miner-web.c
+++ b/src/libtracker-miner/tracker-miner-web.c
@@ -130,7 +130,7 @@ tracker_miner_web_class_init (TrackerMinerWebClass *klass)
static void
tracker_miner_web_init (TrackerMinerWeb *miner)
{
- miner->private = TRACKER_MINER_WEB_GET_PRIVATE (miner);
+ miner->priv = TRACKER_MINER_WEB_GET_PRIVATE (miner);
}
static void
@@ -164,8 +164,8 @@ miner_web_initable_init (GInitable *initable,
}
/* Setup web-interface introspection data */
- mw->private->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &inner_error);
- if (!mw->private->introspection_data) {
+ mw->priv->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &inner_error);
+ if (!mw->priv->introspection_data) {
g_propagate_error (error, inner_error);
return FALSE;
}
@@ -174,10 +174,10 @@ miner_web_initable_init (GInitable *initable,
g_message (" Path:'%s'", tracker_miner_get_dbus_full_path (miner));
g_message (" Object Type:'%s'", G_OBJECT_TYPE_NAME (initable));
- mw->private->registration_id =
+ mw->priv->registration_id =
g_dbus_connection_register_object (tracker_miner_get_dbus_connection (miner),
tracker_miner_get_dbus_full_path (miner),
- mw->private->introspection_data->interfaces[0],
+ mw->priv->introspection_data->interfaces[0],
&interface_vtable,
mw,
NULL,
diff --git a/src/libtracker-miner/tracker-miner-web.h b/src/libtracker-miner/tracker-miner-web.h
index ff1404c..5edbe98 100644
--- a/src/libtracker-miner/tracker-miner-web.h
+++ b/src/libtracker-miner/tracker-miner-web.h
@@ -72,7 +72,7 @@ typedef enum {
struct TrackerMinerWeb {
TrackerMiner parent_instance;
- TrackerMinerWebPrivate *private;
+ TrackerMinerWebPrivate *priv;
};
/**
diff --git a/src/libtracker-miner/tracker-monitor.c b/src/libtracker-miner/tracker-monitor.c
index 737b436..310b08d 100644
--- a/src/libtracker-miner/tracker-monitor.c
+++ b/src/libtracker-miner/tracker-monitor.c
@@ -222,9 +222,9 @@ tracker_monitor_init (TrackerMonitor *object)
const gchar *name;
GError *error = NULL;
- object->private = TRACKER_MONITOR_GET_PRIVATE (object);
+ object->priv = TRACKER_MONITOR_GET_PRIVATE (object);
- priv = object->private;
+ priv = object->priv;
/* By default we enable monitoring */
priv->enabled = TRUE;
@@ -439,7 +439,7 @@ unpause_cb (gpointer data)
"receiving monitor events for %d seconds",
PAUSE_ON_IO_SECONDS);
- monitor->private->unpause_timeout_id = 0;
+ monitor->priv->unpause_timeout_id = 0;
tracker_status_set_is_paused_for_io (FALSE);
return FALSE;
@@ -463,7 +463,7 @@ check_is_directory (TrackerMonitor *monitor,
* hashtable to know whether it was a directory
* we knew about
*/
- if (g_hash_table_lookup (monitor->private->monitors, file) != NULL)
+ if (g_hash_table_lookup (monitor->priv->monitors, file) != NULL)
return TRUE;
}
@@ -544,7 +544,7 @@ tracker_monitor_move (TrackerMonitor *monitor,
old_prefix = g_file_get_path (old_file);
/* Find out which subdirectories should have a file monitor added */
- g_hash_table_iter_init (&iter, monitor->private->monitors);
+ g_hash_table_iter_init (&iter, monitor->priv->monitors);
while (g_hash_table_iter_next (&iter, &iter_file, &iter_file_monitor)) {
GFile *f;
gchar *old_path, *new_path;
@@ -777,18 +777,18 @@ event_pairs_timeout_cb (gpointer user_data)
g_get_current_time (&now);
/* Process PRE-UPDATE hash table */
- event_pairs_process_in_ht (monitor, monitor->private->pre_update, &now);
+ event_pairs_process_in_ht (monitor, monitor->priv->pre_update, &now);
/* Process PRE-DELETE hash table */
- event_pairs_process_in_ht (monitor, monitor->private->pre_delete, &now);
+ event_pairs_process_in_ht (monitor, monitor->priv->pre_delete, &now);
- if (g_hash_table_size (monitor->private->pre_update) > 0 ||
- g_hash_table_size (monitor->private->pre_delete) > 0) {
+ if (g_hash_table_size (monitor->priv->pre_update) > 0 ||
+ g_hash_table_size (monitor->priv->pre_delete) > 0) {
return TRUE;
}
g_debug ("No more events to pair");
- monitor->private->event_pairs_timeout_id = 0;
+ monitor->priv->event_pairs_timeout_id = 0;
return FALSE;
}
@@ -815,7 +815,7 @@ monitor_event_file_created (TrackerMonitor *monitor,
new_event->expirable = FALSE;
#endif /* GIO_ALWAYS_SENDS_CHANGES_DONE_HINT_AFTER_CREATED */
- g_hash_table_replace (monitor->private->pre_update,
+ g_hash_table_replace (monitor->priv->pre_update,
g_object_ref (file),
new_event);
}
@@ -827,18 +827,18 @@ monitor_event_file_changed (TrackerMonitor *monitor,
EventData *previous_update_event_data;
/* Get previous event data, if any */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, file);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, file);
/* If use_changed_event, treat as an ATTRIBUTE_CHANGED. Otherwise,
* assume there will be a CHANGES_DONE_HINT afterwards... */
- if (!monitor->private->use_changed_event) {
+ if (!monitor->priv->use_changed_event) {
/* Process the CHANGED event knowing that there will be a CHANGES_DONE_HINT */
if (previous_update_event_data) {
if (previous_update_event_data->event_type == G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED) {
/* If there is a previous ATTRIBUTE_CHANGED still not notified,
* remove it, as we know there will be a CHANGES_DONE_HINT afterwards
*/
- g_hash_table_remove (monitor->private->pre_update, file);
+ g_hash_table_remove (monitor->priv->pre_update, file);
} else if (previous_update_event_data->event_type == G_FILE_MONITOR_EVENT_CREATED) {
#ifdef GIO_ALWAYS_SENDS_CHANGES_DONE_HINT_AFTER_CREATED
/* If we got a CHANGED event before the CREATED was expired,
@@ -856,7 +856,7 @@ monitor_event_file_changed (TrackerMonitor *monitor,
if (!previous_update_event_data) {
/* If no previous one, insert it */
- g_hash_table_insert (monitor->private->pre_update,
+ g_hash_table_insert (monitor->priv->pre_update,
g_object_ref (file),
event_data_new (file,
NULL,
@@ -867,7 +867,7 @@ monitor_event_file_changed (TrackerMonitor *monitor,
if (previous_update_event_data->event_type == G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED) {
/* Replace the previous ATTRIBUTE_CHANGED event with a CHANGED one. */
- g_hash_table_replace (monitor->private->pre_update,
+ g_hash_table_replace (monitor->priv->pre_update,
g_object_ref (file),
event_data_new (file,
NULL,
@@ -886,10 +886,10 @@ monitor_event_file_attribute_changed (TrackerMonitor *monitor,
EventData *previous_update_event_data;
/* Get previous event data, if any */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, file);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, file);
if (!previous_update_event_data) {
/* If no previous one, insert it */
- g_hash_table_insert (monitor->private->pre_update,
+ g_hash_table_insert (monitor->priv->pre_update,
g_object_ref (file),
event_data_new (file,
NULL,
@@ -916,10 +916,10 @@ monitor_event_file_changes_done (TrackerMonitor *monitor,
EventData *previous_update_event_data;
/* Get previous event data, if any */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, file);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, file);
if (!previous_update_event_data) {
/* Insert new update item in cache */
- g_hash_table_insert (monitor->private->pre_update,
+ g_hash_table_insert (monitor->priv->pre_update,
g_object_ref (file),
event_data_new (file,
NULL,
@@ -941,14 +941,14 @@ monitor_event_file_deleted (TrackerMonitor *monitor,
EventData *previous_update_event_data;
/* Get previous event data, if any */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, file);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, file);
/* Remove any previous pending event (if blacklisting enabled, there may be some) */
if (previous_update_event_data) {
GFileMonitorEvent previous_update_event_type;
previous_update_event_type = previous_update_event_data->event_type;
- g_hash_table_remove (monitor->private->pre_update, file);
+ g_hash_table_remove (monitor->priv->pre_update, file);
if (previous_update_event_type == G_FILE_MONITOR_EVENT_CREATED) {
/* Oh, oh, oh, we got a previous CREATED event waiting in the event
@@ -975,7 +975,7 @@ monitor_event_file_moved (TrackerMonitor *monitor,
EventData *previous_update_event_data;
/* Get previous event data, if any */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, src_file);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, src_file);
/* Some event-merging that can also be enabled if doing blacklisting, as we are
* queueing the CHANGES_DONE_HINT in the cache :
@@ -1000,8 +1000,8 @@ monitor_event_file_moved (TrackerMonitor *monitor,
* Oh, oh, oh, we got a previous created event
* waiting in the event cache... so we remove it, and we
* convert the MOVE event into a CREATED(other_file) */
- g_hash_table_remove (monitor->private->pre_update, src_file);
- g_hash_table_replace (monitor->private->pre_update,
+ g_hash_table_remove (monitor->priv->pre_update, src_file);
+ g_hash_table_replace (monitor->priv->pre_update,
g_object_ref (dst_file),
event_data_new (dst_file,
NULL,
@@ -1016,14 +1016,14 @@ monitor_event_file_moved (TrackerMonitor *monitor,
* (c) ATTR_UPDATED(A) + MOVED(A->B) = MOVED(A->B) + UPDATED(B)
*
* We setup here the UPDATED(B) event, added to the cache */
- g_hash_table_replace (monitor->private->pre_update,
+ g_hash_table_replace (monitor->priv->pre_update,
g_object_ref (dst_file),
event_data_new (dst_file,
NULL,
FALSE,
G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT));
/* Remove previous event */
- g_hash_table_remove (monitor->private->pre_update, src_file);
+ g_hash_table_remove (monitor->priv->pre_update, src_file);
/* And keep on notifying the MOVED event */
}
@@ -1045,14 +1045,14 @@ monitor_event_directory_created_or_changed (TrackerMonitor *monitor,
/* If any previous event on this item, notify it
* before creating it */
- previous_delete_event_data = g_hash_table_lookup (monitor->private->pre_delete, dir);
+ previous_delete_event_data = g_hash_table_lookup (monitor->priv->pre_delete, dir);
if (previous_delete_event_data) {
emit_signal_for_event (monitor, previous_delete_event_data);
- g_hash_table_remove (monitor->private->pre_delete, dir);
+ g_hash_table_remove (monitor->priv->pre_delete, dir);
}
- if (!g_hash_table_lookup (monitor->private->pre_update, dir)) {
- g_hash_table_insert (monitor->private->pre_update,
+ if (!g_hash_table_lookup (monitor->priv->pre_update, dir)) {
+ g_hash_table_insert (monitor->priv->pre_update,
g_object_ref (dir),
event_data_new (dir,
NULL,
@@ -1069,14 +1069,14 @@ monitor_event_directory_deleted (TrackerMonitor *monitor,
EventData *previous_delete_event_data;
/* If any previous update event on this item, notify it */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, dir);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, dir);
if (previous_update_event_data) {
emit_signal_for_event (monitor, previous_update_event_data);
- g_hash_table_remove (monitor->private->pre_update, dir);
+ g_hash_table_remove (monitor->priv->pre_update, dir);
}
/* Check if there is a previous delete event */
- previous_delete_event_data = g_hash_table_lookup (monitor->private->pre_delete, dir);
+ previous_delete_event_data = g_hash_table_lookup (monitor->priv->pre_delete, dir);
if (previous_delete_event_data &&
previous_delete_event_data->event_type == G_FILE_MONITOR_EVENT_MOVED) {
g_debug ("Processing MOVE(A->B) + DELETE(A) as MOVE(A->B) for directory '%s->%s'",
@@ -1084,12 +1084,12 @@ monitor_event_directory_deleted (TrackerMonitor *monitor,
previous_delete_event_data->other_file_uri);
emit_signal_for_event (monitor, previous_delete_event_data);
- g_hash_table_remove (monitor->private->pre_delete, dir);
+ g_hash_table_remove (monitor->priv->pre_delete, dir);
return;
}
/* If no previous, add to HT */
- g_hash_table_replace (monitor->private->pre_delete,
+ g_hash_table_replace (monitor->priv->pre_delete,
g_object_ref (dir),
event_data_new (dir,
NULL,
@@ -1106,14 +1106,14 @@ monitor_event_directory_moved (TrackerMonitor *monitor,
EventData *previous_delete_event_data;
/* If any previous update event on this item, notify it */
- previous_update_event_data = g_hash_table_lookup (monitor->private->pre_update, src_dir);
+ previous_update_event_data = g_hash_table_lookup (monitor->priv->pre_update, src_dir);
if (previous_update_event_data) {
emit_signal_for_event (monitor, previous_update_event_data);
- g_hash_table_remove (monitor->private->pre_update, src_dir);
+ g_hash_table_remove (monitor->priv->pre_update, src_dir);
}
/* Check if there is a previous delete event */
- previous_delete_event_data = g_hash_table_lookup (monitor->private->pre_delete, src_dir);
+ previous_delete_event_data = g_hash_table_lookup (monitor->priv->pre_delete, src_dir);
if (previous_delete_event_data &&
previous_delete_event_data->event_type == G_FILE_MONITOR_EVENT_DELETED) {
EventData *new_event;
@@ -1130,12 +1130,12 @@ monitor_event_directory_moved (TrackerMonitor *monitor,
event_data_free (new_event);
/* And remove the previous DELETE */
- g_hash_table_remove (monitor->private->pre_delete, src_dir);
+ g_hash_table_remove (monitor->priv->pre_delete, src_dir);
return;
}
/* If no previous, add to HT */
- g_hash_table_replace (monitor->private->pre_delete,
+ g_hash_table_replace (monitor->priv->pre_delete,
g_object_ref (src_dir),
event_data_new (src_dir,
dst_dir,
@@ -1157,7 +1157,7 @@ monitor_event_cb (GFileMonitor *file_monitor,
monitor = user_data;
- if (G_UNLIKELY (!monitor->private->enabled)) {
+ if (G_UNLIKELY (!monitor->priv->enabled)) {
g_debug ("Silently dropping monitor event, monitor disabled for now");
return;
}
@@ -1187,8 +1187,8 @@ monitor_event_cb (GFileMonitor *file_monitor,
}
#ifdef PAUSE_ON_IO
- if (monitor->private->unpause_timeout_id != 0) {
- g_source_remove (monitor->private->unpause_timeout_id);
+ if (monitor->priv->unpause_timeout_id != 0) {
+ g_source_remove (monitor->priv->unpause_timeout_id);
} else {
g_message ("Pausing indexing because we are "
"receiving monitor events");
@@ -1196,7 +1196,7 @@ monitor_event_cb (GFileMonitor *file_monitor,
tracker_status_set_is_paused_for_io (TRUE);
}
- monitor->private->unpause_timeout_id =
+ monitor->priv->unpause_timeout_id =
g_timeout_add_seconds (PAUSE_ON_IO_SECONDS,
unpause_cb,
monitor);
@@ -1251,21 +1251,21 @@ monitor_event_cb (GFileMonitor *file_monitor,
}
}
- if (g_hash_table_size (monitor->private->pre_update) > 0 ||
- g_hash_table_size (monitor->private->pre_delete) > 0) {
- if (monitor->private->event_pairs_timeout_id == 0) {
+ if (g_hash_table_size (monitor->priv->pre_update) > 0 ||
+ g_hash_table_size (monitor->priv->pre_delete) > 0) {
+ if (monitor->priv->event_pairs_timeout_id == 0) {
g_debug ("Waiting for event pairs");
- monitor->private->event_pairs_timeout_id =
+ monitor->priv->event_pairs_timeout_id =
g_timeout_add_seconds (CACHE_LIFETIME_SECONDS,
event_pairs_timeout_cb,
monitor);
}
} else {
- if (monitor->private->event_pairs_timeout_id != 0) {
- g_source_remove (monitor->private->event_pairs_timeout_id);
+ if (monitor->priv->event_pairs_timeout_id != 0) {
+ g_source_remove (monitor->priv->event_pairs_timeout_id);
}
- monitor->private->event_pairs_timeout_id = 0;
+ monitor->priv->event_pairs_timeout_id = 0;
}
g_free (file_uri);
@@ -1324,7 +1324,7 @@ tracker_monitor_get_enabled (TrackerMonitor *monitor)
{
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), FALSE);
- return monitor->private->enabled;
+ return monitor->priv->enabled;
}
void
@@ -1338,14 +1338,14 @@ tracker_monitor_set_enabled (TrackerMonitor *monitor,
/* Don't replace all monitors if we are already
* enabled/disabled.
*/
- if (monitor->private->enabled == enabled) {
+ if (monitor->priv->enabled == enabled) {
return;
}
- monitor->private->enabled = enabled;
+ monitor->priv->enabled = enabled;
g_object_notify (G_OBJECT (monitor), "enabled");
- keys = g_hash_table_get_keys (monitor->private->monitors);
+ keys = g_hash_table_get_keys (monitor->priv->monitors);
/* Update state on all monitored dirs */
for (k = keys; k != NULL; k = k->next) {
@@ -1357,11 +1357,11 @@ tracker_monitor_set_enabled (TrackerMonitor *monitor,
GFileMonitor *dir_monitor;
dir_monitor = directory_monitor_new (monitor, file);
- g_hash_table_replace (monitor->private->monitors,
+ g_hash_table_replace (monitor->priv->monitors,
g_object_ref (file), dir_monitor);
} else {
/* Remove monitor */
- g_hash_table_replace (monitor->private->monitors,
+ g_hash_table_replace (monitor->priv->monitors,
g_object_ref (file), NULL);
}
}
@@ -1379,19 +1379,19 @@ tracker_monitor_add (TrackerMonitor *monitor,
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- if (g_hash_table_lookup (monitor->private->monitors, file)) {
+ if (g_hash_table_lookup (monitor->priv->monitors, file)) {
return TRUE;
}
/* Cap the number of monitors */
- if (g_hash_table_size (monitor->private->monitors) >= monitor->private->monitor_limit) {
- monitor->private->monitors_ignored++;
+ if (g_hash_table_size (monitor->priv->monitors) >= monitor->priv->monitor_limit) {
+ monitor->priv->monitors_ignored++;
- if (!monitor->private->monitor_limit_warned) {
+ if (!monitor->priv->monitor_limit_warned) {
g_warning ("The maximum number of monitors to set (%d) "
"has been reached, not adding any new ones",
- monitor->private->monitor_limit);
- monitor->private->monitor_limit_warned = TRUE;
+ monitor->priv->monitor_limit);
+ monitor->priv->monitor_limit_warned = TRUE;
}
return FALSE;
@@ -1399,7 +1399,7 @@ tracker_monitor_add (TrackerMonitor *monitor,
uri = g_file_get_uri (file);
- if (monitor->private->enabled) {
+ if (monitor->priv->enabled) {
/* We don't check if a file exists or not since we might want
* to monitor locations which don't exist yet.
*
@@ -1419,13 +1419,13 @@ tracker_monitor_add (TrackerMonitor *monitor,
* enabled/disabled state changes, we iterate all keys and
* add or remove monitors.
*/
- g_hash_table_insert (monitor->private->monitors,
+ g_hash_table_insert (monitor->priv->monitors,
g_object_ref (file),
dir_monitor);
g_debug ("Added monitor for path:'%s', total monitors:%d",
uri,
- g_hash_table_size (monitor->private->monitors));
+ g_hash_table_size (monitor->priv->monitors));
g_free (uri);
@@ -1441,7 +1441,7 @@ tracker_monitor_remove (TrackerMonitor *monitor,
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- removed = g_hash_table_remove (monitor->private->monitors, file);
+ removed = g_hash_table_remove (monitor->priv->monitors, file);
if (removed) {
gchar *uri;
@@ -1449,7 +1449,7 @@ tracker_monitor_remove (TrackerMonitor *monitor,
uri = g_file_get_uri (file);
g_debug ("Removed monitor for path:'%s', total monitors:%d",
uri,
- g_hash_table_size (monitor->private->monitors));
+ g_hash_table_size (monitor->priv->monitors));
g_free (uri);
}
@@ -1468,7 +1468,7 @@ tracker_monitor_remove_recursively (TrackerMonitor *monitor,
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- g_hash_table_iter_init (&iter, monitor->private->monitors);
+ g_hash_table_iter_init (&iter, monitor->priv->monitors);
while (g_hash_table_iter_next (&iter, &iter_file, &iter_file_monitor)) {
gchar *uri;
@@ -1483,12 +1483,12 @@ tracker_monitor_remove_recursively (TrackerMonitor *monitor,
g_debug ("Removed monitor for path:'%s', total monitors:%d",
uri,
- g_hash_table_size (monitor->private->monitors));
+ g_hash_table_size (monitor->priv->monitors));
g_free (uri);
/* We reset this because now it is possible we have limit - 1 */
- monitor->private->monitor_limit_warned = FALSE;
+ monitor->priv->monitor_limit_warned = FALSE;
items_removed++;
}
@@ -1503,7 +1503,7 @@ monitor_cancel_recursively (TrackerMonitor *monitor,
gpointer iter_file, iter_file_monitor;
guint items_cancelled = 0;
- g_hash_table_iter_init (&iter, monitor->private->monitors);
+ g_hash_table_iter_init (&iter, monitor->priv->monitors);
while (g_hash_table_iter_next (&iter, &iter_file, &iter_file_monitor)) {
gchar *uri;
@@ -1530,7 +1530,7 @@ tracker_monitor_is_watched (TrackerMonitor *monitor,
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
- return g_hash_table_lookup (monitor->private->monitors, file) != NULL;
+ return g_hash_table_lookup (monitor->priv->monitors, file) != NULL;
}
gboolean
@@ -1544,7 +1544,7 @@ tracker_monitor_is_watched_by_string (TrackerMonitor *monitor,
g_return_val_if_fail (path != NULL, FALSE);
file = g_file_new_for_path (path);
- watched = g_hash_table_lookup (monitor->private->monitors, file) != NULL;
+ watched = g_hash_table_lookup (monitor->priv->monitors, file) != NULL;
g_object_unref (file);
return watched;
@@ -1555,7 +1555,7 @@ tracker_monitor_get_count (TrackerMonitor *monitor)
{
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), 0);
- return g_hash_table_size (monitor->private->monitors);
+ return g_hash_table_size (monitor->priv->monitors);
}
guint
@@ -1563,5 +1563,5 @@ tracker_monitor_get_ignored (TrackerMonitor *monitor)
{
g_return_val_if_fail (TRACKER_IS_MONITOR (monitor), 0);
- return monitor->private->monitors_ignored;
+ return monitor->priv->monitors_ignored;
}
diff --git a/src/libtracker-miner/tracker-monitor.h b/src/libtracker-miner/tracker-monitor.h
index accca05..4568e78 100644
--- a/src/libtracker-miner/tracker-monitor.h
+++ b/src/libtracker-miner/tracker-monitor.h
@@ -42,7 +42,7 @@ typedef struct TrackerMonitorPrivate TrackerMonitorPrivate;
struct TrackerMonitor {
GObject parent;
- TrackerMonitorPrivate *private;
+ TrackerMonitorPrivate *priv;
};
struct TrackerMonitorClass {
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
