This file is indexed.

/usr/include/tracker-1.0/libtracker-control/tracker-miner-manager.h is in libtracker-control-1.0-dev 1.6.2-0ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/*
 * Copyright (C) 2009, Nokia <ivan.frade@nokia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#ifndef __LIBTRACKER_CONTROL_MANAGER_H__
#define __LIBTRACKER_CONTROL_MANAGER_H__

#if !defined (__LIBTRACKER_CONTROL_H_INSIDE__) && !defined (TRACKER_COMPILATION)
#error "Only <libtracker-control/tracker-control.h> can be included directly."
#endif

#include <gio/gio.h>

G_BEGIN_DECLS

#define TRACKER_TYPE_MINER_MANAGER         (tracker_miner_manager_get_type())
#define TRACKER_MINER_MANAGER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), TRACKER_TYPE_MINER_MANAGER, TrackerMinerManager))
#define TRACKER_MINER_MANAGER_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c),    TRACKER_TYPE_MINER_MANAGER, TrackerMinerManagerClass))
#define TRACKER_IS_MINER_MANAGER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), TRACKER_TYPE_MINER_MANAGER))
#define TRACKER_IS_MINER_MANAGER_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c),    TRACKER_TYPE_MINER_MANAGER))
#define TRACKER_MINER_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),  TRACKER_TYPE_MINER_MANAGER, TrackerMinerManagerClass))

#define TRACKER_MINER_MANAGER_ERROR tracker_miner_manager_error_quark ()

typedef struct _TrackerMinerManager TrackerMinerManager;

/**
 * TrackerMinerManagerError:
 * @TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE: The miner in question
 * is not active and can so can not be used.
 * @TRACKER_MINER_MANAGER_ERROR_NOENT: The resource that the
 * miner is handling (for example a file or URI) does not exist.
 *
 * Enumeration values used in errors returned by the
 * #TrackerMinerManager API.
 *
 * Since: 0.8
 **/
typedef enum {
	TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE,
	TRACKER_MINER_MANAGER_ERROR_NOENT
} TrackerMinerManagerError;

/**
 * TrackerMinerManager:
 *
 * Object to query and control miners.
 **/
struct _TrackerMinerManager {
	GObject parent_instance;
};

/**
 * TrackerMinerManagerClass:
 * @miner_progress: The progress signal for all miners including name,
 * status and progress as a percentage between 0 and 1.
 * @miner_paused: The paused signal for all miners known about.
 * @miner_resumed: The resumed signal for all miners known about.
 * @miner_activated: The activated signal for all miners which
 * indicates the miner is available on d-bus.
 * @miner_deactivated: The deactivate for all miners which indicates
 * the miner is no longer available on d-bus.
 **/
typedef struct {
	GObjectClass parent_class;

	void (* miner_progress)    (TrackerMinerManager *manager,
	                            const gchar         *miner_name,
	                            const gchar         *status,
	                            gdouble              progress);
	void (* miner_paused)      (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_resumed)     (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_activated)   (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_deactivated) (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
} TrackerMinerManagerClass;

GType                tracker_miner_manager_get_type           (void) G_GNUC_CONST;
GQuark               tracker_miner_manager_error_quark        (void) G_GNUC_CONST;

TrackerMinerManager *tracker_miner_manager_new                (void);
TrackerMinerManager *tracker_miner_manager_new_full           (gboolean              auto_start,
                                                               GError              **error);
GSList *             tracker_miner_manager_get_running        (TrackerMinerManager  *manager);
GSList *             tracker_miner_manager_get_available      (TrackerMinerManager  *manager);
gboolean             tracker_miner_manager_pause              (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               const gchar          *reason,
                                                               guint32              *cookie);
gboolean             tracker_miner_manager_pause_for_process  (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               const gchar          *reason,
                                                               guint32              *cookie);
gboolean             tracker_miner_manager_resume             (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               guint32               cookie);
gboolean             tracker_miner_manager_is_active          (TrackerMinerManager  *manager,
                                                               const gchar          *miner);
gboolean             tracker_miner_manager_is_paused          (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               GStrv                *applications,
                                                               GStrv                *reasons);
gboolean             tracker_miner_manager_get_status         (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               gchar               **status,
                                                               gdouble              *progress,
                                                               gint                 *remaining_time);
const gchar *        tracker_miner_manager_get_display_name   (TrackerMinerManager  *manager,
                                                               const gchar          *miner);
const gchar *        tracker_miner_manager_get_description    (TrackerMinerManager  *manager,
                                                               const gchar          *miner);

gboolean             tracker_miner_manager_reindex_by_mimetype (TrackerMinerManager  *manager,
                                                                const GStrv           mimetypes,
                                                                GError              **error);
gboolean             tracker_miner_manager_index_file          (TrackerMinerManager  *manager,
                                                                GFile                *file,
                                                                GError              **error);
void                 tracker_miner_manager_index_file_async    (TrackerMinerManager  *manager,
                                                                GFile                *file,
                                                                GCancellable         *cancellable,
                                                                GAsyncReadyCallback   callback,
                                                                gpointer              user_data);
gboolean             tracker_miner_manager_index_file_finish   (TrackerMinerManager  *manager,
                                                                GAsyncResult         *result,
                                                                GError              **error);

#ifndef TRACKER_DISABLE_DEPRECATED
gboolean             tracker_miner_manager_ignore_next_update (TrackerMinerManager  *manager,
                                                               const gchar          *miner,
                                                               const gchar         **urls) G_GNUC_DEPRECATED;
#endif /* TRACKER_DISABLE_DEPRECATED */

G_END_DECLS

#endif /* __LIBTRACKER_CONTROL_MANAGER_H__ */