![]() |
![]() |
![]() |
Tracker Miner Library Reference Manual | ![]() |
---|---|---|---|---|
Top | Description | Object Hierarchy | Properties | Signals |
#include <libtracker-miner/tracker-miner.h> typedef TrackerMiner; TrackerMinerClass; GQuark tracker_miner_error_quark (void
); void tracker_miner_start (TrackerMiner *miner
); void tracker_miner_stop (TrackerMiner *miner
); gboolean tracker_miner_is_started (TrackerMiner *miner
); void tracker_miner_execute_update (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); void tracker_miner_execute_sparql (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); void tracker_miner_execute_batch_update (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); void tracker_miner_commit (TrackerMiner *miner
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gint tracker_miner_pause (TrackerMiner *miner
,const gchar *reason
,GError **error
); gboolean tracker_miner_resume (TrackerMiner *miner
,gint cookie
,GError **error
);
"name" gchar* : Read / Write / Construct Only "progress" gdouble : Read / Write "status" gchar* : Read / Write
"error" : Run Last "paused" : Run Last "progress" : Run Last "resumed" : Run Last "started" : Run Last "stopped" : Run Last "writeback" : Run Last
TrackerMiner is an abstract base class to help developing data miners for tracker-store, being an abstract class it doesn't do much by itself, but provides the basic signaling and operation control so the miners implementing this class are properly recognized by Tracker, and can be controlled properly by external means such as TrackerMinerManager.
typedef struct { GObjectClass parent_class; /* signals */ void (* started) (TrackerMiner *miner); void (* stopped) (TrackerMiner *miner); void (* paused) (TrackerMiner *miner); void (* resumed) (TrackerMiner *miner); void (* progress) (TrackerMiner *miner, const gchar *status, gdouble progress); void (* error) (TrackerMiner *miner, GError *error); void (* writeback) (TrackerMiner *miner, const GStrv subjects); } TrackerMinerClass;
Virtual methods left to implement.
GObjectClass |
parent object class. |
Called when the miner is told to start collecting data. | |
Called when the miner is told to stop collecting data. | |
Called when the miner is told to pause. | |
Called when the miner is told to resume activity. | |
progress. | |
error. | |
Called after writeback event happens. |
GQuark tracker_miner_error_quark (void
);
Returns the GQuark used to identify miner errors in GError structures.
Returns : |
the error GQuark |
void tracker_miner_start (TrackerMiner *miner
);
Tells the miner to start processing data.
|
a TrackerMiner |
void tracker_miner_stop (TrackerMiner *miner
);
Tells the miner to stop processing data.
|
a TrackerMiner |
gboolean tracker_miner_is_started (TrackerMiner *miner
);
Returns TRUE if the miner has been started.
|
a TrackerMiner |
Returns : |
TRUE if the miner is already started. |
void tracker_miner_execute_update (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Executes an update SPARQL query on tracker-store, use this whenever you want to perform data insertions or modifications.
When the operation is finished, callback
will be called, providing a GAsyncResult
object. Call tracker_miner_execute_sparql_finish on it to get the returned GError,
if there is one.
If the operation is cancelled, callback
will be called anyway, with the GAsyncResult
object containing an error.
|
a TrackerMiner |
|
a SPARQL query |
|
a GCancellable to control the operation |
|
a GAsyncReadyCallback to call when the operation is finished |
|
data to pass to callback
|
void tracker_miner_execute_sparql (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Executes the SPARQL query on tracker-store and returns asynchronously the queried data. Use this whenever you need to get data from already stored information.
When the operation is finished, callback
will be called, providing a GAsyncResult
object. Call tracker_miner_execute_sparql_finish on it to get the query results, or
the GError object if an error occured.
If the operation is cancelled, callback
will be called anyway, with the GAsyncResult
object containing an error.
|
a TrackerMiner |
|
a SPARQL query |
|
a GCancellable to control the operation |
|
a GAsyncReadyCallback to call when the operation is finished |
|
data to pass to callback
|
void tracker_miner_execute_batch_update (TrackerMiner *miner
,const gchar *sparql
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Executes a batch of update SPARQL queries on tracker-store, use this whenever you want to perform data insertions or modifications in batches.
When the operation is finished, callback
will be called, providing a GAsyncResult
object. Call tracker_miner_execute_batch_update_finish on it to get the returned GError,
if there is one.
If the operation is cancelled, callback
will be called anyway, with the GAsyncResult
object containing an error.
|
a TrackerMiner |
|
a set of SPARQL updates |
|
a GCancellable to control the operation |
|
a GAsyncReadyCallback to call when the operation is finished |
|
data to pass to callback
|
void tracker_miner_commit (TrackerMiner *miner
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Commits all pending batch updates. See tracker_miner_execute_batch_update()
.
When the operation is finished, callback
will be called, providing a GAsyncResult
object. Call tracker_miner_commit_finish on it to get the returned GError,
if there is one.
If the operation is cancelled, callback
will be called anyway, with the GAsyncResult
object containing an error.
|
a TrackerMiner |
|
a GCancellable to control the operation |
|
a GAsyncReadyCallback to call when the operation is finished |
|
data to pass to callback
|
gint tracker_miner_pause (TrackerMiner *miner
,const gchar *reason
,GError **error
);
Asks miner
to pause. On success the cookie ID is returned,
this is what must be used in tracker_miner_resume()
to resume
operations. On failure error
will be set and -1 will be returned.
|
a TrackerMiner |
|
reason to pause |
|
return location for errors |
Returns : |
The pause cookie ID. |
gboolean tracker_miner_resume (TrackerMiner *miner
,gint cookie
,GError **error
);
Asks the miner to resume processing. The cookie must be something
returned by tracker_miner_pause()
. The miner won't actually resume
operations until all pause requests have been resumed.
|
a TrackerMiner |
|
pause cookie |
|
return location for errors |
Returns : |
TRUE if the cookie was valid. |
"progress"
property"progress" gdouble : Read / Write
Miner progress.
Allowed values: [0,1]
Default value: 0
"status"
property"status" gchar* : Read / Write
Translatable string with status description.
Default value: NULL
"error"
signalvoid user_function (TrackerMiner *miner, gpointer error, gpointer user_data) : Run Last
The ::error signal will be emitted by TrackerMiner implementations to indicate some error in the data mining process.
|
the TrackerMiner |
|
the error that happened |
|
user data set when the signal handler was connected. |
"paused"
signalvoid user_function (TrackerMiner *miner, gpointer user_data) : Run Last
the ::paused signal is emitted whenever
there is any reason to pause, either
internal (through tracker_miner_pause()
) or
external (through DBus, see TrackerMinerManager).
|
the TrackerMiner |
|
user data set when the signal handler was connected. |
"progress"
signalvoid user_function (TrackerMiner *miner, gchar *status, gdouble progress, gpointer user_data) : Run Last
the ::progress signal will be emitted by TrackerMiner implementations
to indicate progress about the data mining process. status
will
contain a translated string with the current miner status and progress
will indicate how much has been processed so far.
|
the TrackerMiner |
|
miner status |
|
a gdouble indicating miner progress, from 0 to 1. |
|
user data set when the signal handler was connected. |
"resumed"
signalvoid user_function (TrackerMiner *miner, gpointer user_data) : Run Last
the ::resumed signal is emitted whenever
all reasons to pause have disappeared, see
tracker_miner_resume()
and TrackerMinerManager.
|
the TrackerMiner |
|
user data set when the signal handler was connected. |
"started"
signalvoid user_function (TrackerMiner *miner, gpointer user_data) : Run Last
the ::started signal is emitted in the miner
right after it has been started through
tracker_miner_start()
.
|
the TrackerMiner |
|
user data set when the signal handler was connected. |
"stopped"
signalvoid user_function (TrackerMiner *miner, gpointer user_data) : Run Last
the ::stopped signal is emitted in the miner
right after it has been stopped through
tracker_miner_stop()
.
|
the TrackerMiner |
|
user data set when the signal handler was connected. |
"writeback"
signalvoid user_function (TrackerMiner *miner, GStrv *subjects, gpointer user_data) : Run Last
the ::writeback signal is emitted in the miner
right after it has been asked to mark subjects
as writeback through
tracker_miner_writeback()
.
|
the TrackerMiner |
|
the subjects to mark as writeback |
|
user data set when the signal handler was connected. |