![]() |
![]() |
![]() |
Tracker Miner Library Reference Manual | ![]() |
---|---|---|---|---|
Top | Description | Object Hierarchy | Properties | Signals |
#include <libtracker-miner/tracker-miner.h> typedef TrackerMinerFSPrivate; typedef TrackerMinerFS; TrackerMinerFSClass; void tracker_miner_fs_directory_add (TrackerMinerFS *fs
,GFile *file
,gboolean recurse
); gboolean tracker_miner_fs_directory_remove (TrackerMinerFS *fs
,GFile *file
); void tracker_miner_fs_file_add (TrackerMinerFS *fs
,GFile *file
); void tracker_miner_fs_file_notify (TrackerMinerFS *fs
,GFile *file
,const GError *error
); void tracker_miner_fs_set_throttle (TrackerMinerFS *fs
,gdouble throttle
); gdouble tracker_miner_fs_get_throttle (TrackerMinerFS *fs
); void tracker_miner_fs_force_recheck (TrackerMinerFS *fs
); const gchar * tracker_miner_fs_get_parent_urn (TrackerMinerFS *fs
,GFile *file
); const gchar * tracker_miner_fs_get_urn (TrackerMinerFS *fs
,GFile *file
);
"check-directory" : Run Last "check-directory-contents" : Run Last "check-file" : Run Last "finished" : Run Last "ignore-next-update-file" : Run Last "monitor-directory" : Run Last "process-file" : Run Last
TrackerMinerFS is an abstract base class for miners that collect data from the filesystem, all the filesystem crawling and monitoring is abstracted away, leaving to implementations the decisions of what directories/files should it process, and the actual data extraction.
typedef struct TrackerMinerFS TrackerMinerFS;
Abstract miner abstract implementation to get data from the filesystem.
typedef struct { TrackerMinerClass parent; gboolean (* check_file) (TrackerMinerFS *fs, GFile *file); gboolean (* check_directory) (TrackerMinerFS *fs, GFile *file); gboolean (* check_directory_contents) (TrackerMinerFS *fs, GFile *parent, GList *children); gboolean (* process_file) (TrackerMinerFS *fs, GFile *file, TrackerSparqlBuilder *builder, GCancellable *cancellable); gboolean (* ignore_next_update_file) (TrackerMinerFS *fs, GFile *file, TrackerSparqlBuilder *builder, GCancellable *cancellable); gboolean (* monitor_directory) (TrackerMinerFS *fs, GFile *file); void (* finished) (TrackerMinerFS *fs); } TrackerMinerFSClass;
Prototype for the abstract class, check_file
, check_directory
, check_directory_contents
,
process_file
and monitor_directory
must be implemented in the deriving class in order to
actually extract data.
TrackerMinerClass |
parent object class |
Called when a file should be checked for further processing | |
Called when a directory should be checked for further processing | |
Called when a directory should be checked for further processing, based on the directory contents. | |
Called when the metadata associated to a file is requested. | |
Called after a writeback event happens on a file. | |
Called to check whether a directory should be modified. | |
Called when all processing has been performed. |
void tracker_miner_fs_directory_add (TrackerMinerFS *fs
,GFile *file
,gboolean recurse
);
Tells the filesystem miner to inspect a directory.
|
a TrackerMinerFS |
|
GFile for the directory to inspect |
|
whether the directory should be inspected recursively |
gboolean tracker_miner_fs_directory_remove (TrackerMinerFS *fs
,GFile *file
);
Removes a directory from being inspected by fs
.
|
a TrackerMinerFS |
|
GFile for the directory to be removed |
Returns : |
TRUE if the directory was successfully removed.
|
void tracker_miner_fs_file_add (TrackerMinerFS *fs
,GFile *file
);
Tells the filesystem miner to inspect a file.
|
a TrackerMinerFS |
|
GFile for the file to inspect |
void tracker_miner_fs_file_notify (TrackerMinerFS *fs
,GFile *file
,const GError *error
);
Notifies fs
that all processing on file
has been finished, if any error
happened during file data processing, it should be passed in error
, else
that parameter will contain NULL
to reflect success.
|
a TrackerMinerFS |
|
a GFile |
|
a GError with the error that happened during processing, or NULL .
|
void tracker_miner_fs_set_throttle (TrackerMinerFS *fs
,gdouble throttle
);
Tells the filesystem miner to throttle its operations. a value of 0 means no throttling at all, so the miner will perform operations at full speed, 1 is the slowest value.
|
a TrackerMinerFS |
|
throttle value, between 0 and 1 |
gdouble tracker_miner_fs_get_throttle (TrackerMinerFS *fs
);
Gets the current throttle value. see tracker_miner_fs_set_throttle()
.
|
a TrackerMinerFS |
Returns : |
current throttle value. |
const gchar * tracker_miner_fs_get_parent_urn (TrackerMinerFS *fs
,GFile *file
);
If file
is currently being processed by fs
, this function
will return the parent folder URN if any. This function is
useful to set the nie:belongsToContainer relationship. The
processing order of TrackerMinerFS guarantees that a folder
has been already fully processed for indexing before any
children is processed, so most usually this function should
return non-NULL
.
|
a TrackerMinerFS |
|
a GFile obtained in "process-file" |
Returns : |
The parent folder URN, or NULL .
|
const gchar * tracker_miner_fs_get_urn (TrackerMinerFS *fs
,GFile *file
);
If the item exists in the store, this function retrieves the URN for a GFile being currently processed.
If file
is not being currently processed by fs
, or doesn't
exist in the store yet, NULL
will be returned.
|
a TrackerMinerFS |
|
a GFile obtained in "process-file" |
Returns : |
The URN containing the data associated to file ,
or NULL .
|
"process-pool-limit"
property"process-pool-limit" guint : Read / Write / Construct
Number of files that can be concurrently processed.
Allowed values: >= 1
Default value: 1
"throttle"
property"throttle" gdouble : Read / Write
Modifier for the indexing speed, 0 is max speed.
Allowed values: [0,1]
Default value: 0
"check-directory"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *directory, gpointer user_data) : Run Last
The ::check-directory signal is emitted either on the filesystem crawling
phase or whenever a new directory appears in a monitored directory
in order to check whether directory
must be inspected my miner_fs
.
|
the TrackerMinerFS |
|
a GFile |
|
user data set when the signal handler was connected. |
Returns : |
TRUE if directory must be inspected.
|
"check-directory-contents"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *directory, gpointer children, gpointer user_data) : Run Last
The ::check-directory-contents signal is emitted either on the filesystem
crawling phase or whenever a new directory appears in a monitored directory
in order to check whether directory
must be inspected my miner_fs
based on
the directory contents, for some implementations this signal may be useful
to discard backup directories for example.
|
the TrackerMinerFS |
|
a GFile |
|
GList of GFiles |
|
user data set when the signal handler was connected. |
Returns : |
TRUE if directory must be inspected.
|
"check-file"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *file, gpointer user_data) : Run Last
The ::check-file signal is emitted either on the filesystem crawling
phase or whenever a new file appears in a monitored directory
in order to check whether file
must be inspected my miner_fs
.
|
the TrackerMinerFS |
|
a GFile |
|
user data set when the signal handler was connected. |
Returns : |
TRUE if file must be inspected.
|
"finished"
signalvoid user_function (TrackerMinerFS *miner_fs, gdouble elapsed, guint directories_found, guint directories_ignored, guint files_found, guint files_ignored, gpointer user_data) : Run Last
The ::finished signal is emitted when miner_fs
has finished
all pending processing.
|
the TrackerMinerFS |
|
elapsed time since mining was started |
|
number of directories found |
|
number of ignored directories |
|
number of files found |
|
number of ignored files |
|
user data set when the signal handler was connected. |
"ignore-next-update-file"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *file, TrackerSparqlBuilder *builder, GCancellable *cancellable, gpointer user_data) : Run Last
The ::ignore-next-update-file signal is emitted whenever a file should be marked as to ignore on next update, and it's metadata prepared for that.
builder
is the TrackerSparqlBuilder where all sparql updates
to be performed for file
will be appended.
|
the TrackerMinerFS |
|
a GFile |
|
a TrackerSparqlBuilder |
|
a GCancellable |
|
user data set when the signal handler was connected. |
Returns : |
TRUE on success
FALSE on failure
|
"monitor-directory"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *directory, gpointer user_data) : Run Last
The ::monitor-directory is emitted either on the filesystem crawling phase
or whenever a new directory appears in a monitored directory in order to
check whether directory
must be monitored for filesystem changes or not.
|
the TrackerMinerFS |
|
a GFile |
|
user data set when the signal handler was connected. |
Returns : |
TRUE if the directory must be monitored for changes.
|
"process-file"
signalgboolean user_function (TrackerMinerFS *miner_fs, GFile *file, TrackerSparqlBuilder *builder, GCancellable *cancellable, gpointer user_data) : Run Last
The ::process-file signal is emitted whenever a file should be processed, and it's metadata extracted.
builder
is the TrackerSparqlBuilder where all sparql updates
to be performed for file
will be appended.
This signal allows both synchronous and asynchronous extraction,
in the synchronous case cancellable
can be safely ignored. In
either case, on successful metadata extraction, implementations
must call tracker_miner_fs_file_notify()
to indicate that
processing has finished on file
, so the miner can execute
the SPARQL updates and continue processing other files.
|
the TrackerMinerFS |
|
a GFile |
|
a TrackerSparqlBuilder |
|
a GCancellable |
|
user data set when the signal handler was connected. |
Returns : |
TRUE if the file is accepted for processing,
FALSE if the file should be ignored.
|