1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
8#![cfg_attr(docsrs, feature(doc_cfg))]
9
10use gio_sys as gio;
11use glib_sys as glib;
12use gobject_sys as gobject;
13
14#[allow(unused_imports)]
15use std::ffi::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
16 c_short, c_ushort, c_long, c_ulong, c_void};
17#[allow(unused_imports)]
18use libc::{size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22
23#[allow(unused_imports)]
24use glib::{gboolean, gconstpointer, gpointer, GType};
25
26pub type TrackerDeserializeFlags = c_int;
28pub const TRACKER_DESERIALIZE_FLAGS_NONE: TrackerDeserializeFlags = 0;
29
30pub type TrackerNotifierEventType = c_int;
31pub const TRACKER_NOTIFIER_EVENT_CREATE: TrackerNotifierEventType = 0;
32pub const TRACKER_NOTIFIER_EVENT_DELETE: TrackerNotifierEventType = 1;
33pub const TRACKER_NOTIFIER_EVENT_UPDATE: TrackerNotifierEventType = 2;
34
35pub type TrackerRdfFormat = c_int;
36pub const TRACKER_RDF_FORMAT_TURTLE: TrackerRdfFormat = 0;
37pub const TRACKER_RDF_FORMAT_TRIG: TrackerRdfFormat = 1;
38pub const TRACKER_RDF_FORMAT_JSON_LD: TrackerRdfFormat = 2;
39pub const TRACKER_RDF_FORMAT_LAST: TrackerRdfFormat = 3;
40
41pub type TrackerSerializeFlags = c_int;
42pub const TRACKER_SERIALIZE_FLAGS_NONE: TrackerSerializeFlags = 0;
43
44pub type TrackerSparqlError = c_int;
45pub const TRACKER_SPARQL_ERROR_CONSTRAINT: TrackerSparqlError = 0;
46pub const TRACKER_SPARQL_ERROR_INTERNAL: TrackerSparqlError = 1;
47pub const TRACKER_SPARQL_ERROR_NO_SPACE: TrackerSparqlError = 2;
48pub const TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND: TrackerSparqlError = 3;
49pub const TRACKER_SPARQL_ERROR_OPEN_ERROR: TrackerSparqlError = 4;
50pub const TRACKER_SPARQL_ERROR_PARSE: TrackerSparqlError = 5;
51pub const TRACKER_SPARQL_ERROR_QUERY_FAILED: TrackerSparqlError = 6;
52pub const TRACKER_SPARQL_ERROR_TYPE: TrackerSparqlError = 7;
53pub const TRACKER_SPARQL_ERROR_UNKNOWN_CLASS: TrackerSparqlError = 8;
54pub const TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH: TrackerSparqlError = 9;
55pub const TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY: TrackerSparqlError = 10;
56pub const TRACKER_SPARQL_ERROR_UNSUPPORTED: TrackerSparqlError = 11;
57pub const TRACKER_SPARQL_ERROR_MISSING_LAST_MODIFIED_HEADER: TrackerSparqlError = 12;
58pub const TRACKER_SPARQL_ERROR_INCOMPLETE_PROPERTY_DEFINITION: TrackerSparqlError = 13;
59pub const TRACKER_SPARQL_ERROR_CORRUPT: TrackerSparqlError = 14;
60pub const TRACKER_SPARQL_ERROR_LAST: TrackerSparqlError = 15;
61
62pub type TrackerSparqlValueType = c_int;
63pub const TRACKER_SPARQL_VALUE_TYPE_UNBOUND: TrackerSparqlValueType = 0;
64pub const TRACKER_SPARQL_VALUE_TYPE_URI: TrackerSparqlValueType = 1;
65pub const TRACKER_SPARQL_VALUE_TYPE_STRING: TrackerSparqlValueType = 2;
66pub const TRACKER_SPARQL_VALUE_TYPE_INTEGER: TrackerSparqlValueType = 3;
67pub const TRACKER_SPARQL_VALUE_TYPE_DOUBLE: TrackerSparqlValueType = 4;
68pub const TRACKER_SPARQL_VALUE_TYPE_DATETIME: TrackerSparqlValueType = 5;
69pub const TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE: TrackerSparqlValueType = 6;
70pub const TRACKER_SPARQL_VALUE_TYPE_BOOLEAN: TrackerSparqlValueType = 7;
71
72pub const TRACKER_MAJOR_VERSION: c_int = 3;
74pub const TRACKER_MICRO_VERSION: c_int = 0;
75pub const TRACKER_MINOR_VERSION: c_int = 10;
76pub const TRACKER_PREFIX_DC: &[u8] = b"http://purl.org/dc/elements/1.1/\0";
77pub const TRACKER_PREFIX_MFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/mfo#\0";
78pub const TRACKER_PREFIX_NAO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nao#\0";
79pub const TRACKER_PREFIX_NCO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nco#\0";
80pub const TRACKER_PREFIX_NFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nfo#\0";
81pub const TRACKER_PREFIX_NIE: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nie#\0";
82pub const TRACKER_PREFIX_NMM: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nmm#\0";
83pub const TRACKER_PREFIX_NRL: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nrl#\0";
84pub const TRACKER_PREFIX_OSINFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/osinfo#\0";
85pub const TRACKER_PREFIX_RDF: &[u8] = b"http://www.w3.org/1999/02/22-rdf-syntax-ns#\0";
86pub const TRACKER_PREFIX_RDFS: &[u8] = b"http://www.w3.org/2000/01/rdf-schema#\0";
87pub const TRACKER_PREFIX_SLO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/slo#\0";
88pub const TRACKER_PREFIX_TRACKER: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/tracker#\0";
89pub const TRACKER_PREFIX_XSD: &[u8] = b"http://www.w3.org/2001/XMLSchema#\0";
90
91pub type TrackerSparqlConnectionFlags = c_uint;
93pub const TRACKER_SPARQL_CONNECTION_FLAGS_NONE: TrackerSparqlConnectionFlags = 0;
94pub const TRACKER_SPARQL_CONNECTION_FLAGS_READONLY: TrackerSparqlConnectionFlags = 1;
95pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STEMMER: TrackerSparqlConnectionFlags = 2;
96pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_UNACCENT: TrackerSparqlConnectionFlags = 4;
97pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STOP_WORDS: TrackerSparqlConnectionFlags = 8;
98pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_IGNORE_NUMBERS: TrackerSparqlConnectionFlags = 16;
99pub const TRACKER_SPARQL_CONNECTION_FLAGS_ANONYMOUS_BNODES: TrackerSparqlConnectionFlags = 32;
100
101#[repr(C)]
103#[allow(dead_code)]
104pub struct _TrackerBatchClass {
105 _data: [u8; 0],
106 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
107}
108
109pub type TrackerBatchClass = _TrackerBatchClass;
110
111#[repr(C)]
112#[allow(dead_code)]
113pub struct _TrackerEndpointClass {
114 _data: [u8; 0],
115 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
116}
117
118pub type TrackerEndpointClass = _TrackerEndpointClass;
119
120#[derive(Copy, Clone)]
121#[repr(C)]
122pub struct TrackerNamespaceManagerClass {
123 pub parent_class: gobject::GObjectClass,
124}
125
126impl ::std::fmt::Debug for TrackerNamespaceManagerClass {
127 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
128 f.debug_struct(&format!("TrackerNamespaceManagerClass @ {self:p}"))
129 .field("parent_class", &self.parent_class)
130 .finish()
131 }
132}
133
134#[repr(C)]
135#[allow(dead_code)]
136pub struct _TrackerNotifierClass {
137 _data: [u8; 0],
138 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
139}
140
141pub type TrackerNotifierClass = _TrackerNotifierClass;
142
143#[repr(C)]
144#[allow(dead_code)]
145pub struct TrackerNotifierEvent {
146 _data: [u8; 0],
147 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
148}
149
150impl ::std::fmt::Debug for TrackerNotifierEvent {
151 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
152 f.debug_struct(&format!("TrackerNotifierEvent @ {self:p}"))
153 .finish()
154 }
155}
156
157#[repr(C)]
158#[allow(dead_code)]
159pub struct _TrackerResourceClass {
160 _data: [u8; 0],
161 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
162}
163
164pub type TrackerResourceClass = _TrackerResourceClass;
165
166#[repr(C)]
167#[allow(dead_code)]
168pub struct _TrackerSparqlConnectionClass {
169 _data: [u8; 0],
170 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
171}
172
173pub type TrackerSparqlConnectionClass = _TrackerSparqlConnectionClass;
174
175#[repr(C)]
176#[allow(dead_code)]
177pub struct _TrackerSparqlCursorClass {
178 _data: [u8; 0],
179 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
180}
181
182pub type TrackerSparqlCursorClass = _TrackerSparqlCursorClass;
183
184#[repr(C)]
185#[allow(dead_code)]
186pub struct _TrackerSparqlStatementClass {
187 _data: [u8; 0],
188 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
189}
190
191pub type TrackerSparqlStatementClass = _TrackerSparqlStatementClass;
192
193#[derive(Copy, Clone)]
195#[repr(C)]
196pub struct TrackerBatch {
197 pub parent_instance: gobject::GObject,
198}
199
200impl ::std::fmt::Debug for TrackerBatch {
201 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
202 f.debug_struct(&format!("TrackerBatch @ {self:p}"))
203 .field("parent_instance", &self.parent_instance)
204 .finish()
205 }
206}
207
208#[derive(Copy, Clone)]
209#[repr(C)]
210pub struct TrackerEndpoint {
211 pub parent_instance: gobject::GObject,
212}
213
214impl ::std::fmt::Debug for TrackerEndpoint {
215 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
216 f.debug_struct(&format!("TrackerEndpoint @ {self:p}"))
217 .field("parent_instance", &self.parent_instance)
218 .finish()
219 }
220}
221
222#[repr(C)]
223#[allow(dead_code)]
224pub struct TrackerEndpointDBus {
225 _data: [u8; 0],
226 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
227}
228
229impl ::std::fmt::Debug for TrackerEndpointDBus {
230 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
231 f.debug_struct(&format!("TrackerEndpointDBus @ {self:p}"))
232 .finish()
233 }
234}
235
236#[repr(C)]
237#[allow(dead_code)]
238pub struct TrackerEndpointHttp {
239 _data: [u8; 0],
240 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
241}
242
243impl ::std::fmt::Debug for TrackerEndpointHttp {
244 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
245 f.debug_struct(&format!("TrackerEndpointHttp @ {self:p}"))
246 .finish()
247 }
248}
249
250#[repr(C)]
251#[allow(dead_code)]
252pub struct TrackerNamespaceManager {
253 _data: [u8; 0],
254 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
255}
256
257impl ::std::fmt::Debug for TrackerNamespaceManager {
258 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
259 f.debug_struct(&format!("TrackerNamespaceManager @ {self:p}"))
260 .finish()
261 }
262}
263
264#[derive(Copy, Clone)]
265#[repr(C)]
266pub struct TrackerNotifier {
267 pub parent_instance: gobject::GObject,
268}
269
270impl ::std::fmt::Debug for TrackerNotifier {
271 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
272 f.debug_struct(&format!("TrackerNotifier @ {self:p}"))
273 .field("parent_instance", &self.parent_instance)
274 .finish()
275 }
276}
277
278#[derive(Copy, Clone)]
279#[repr(C)]
280pub struct TrackerResource {
281 pub parent_instance: gobject::GObject,
282}
283
284impl ::std::fmt::Debug for TrackerResource {
285 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
286 f.debug_struct(&format!("TrackerResource @ {self:p}"))
287 .field("parent_instance", &self.parent_instance)
288 .finish()
289 }
290}
291
292#[derive(Copy, Clone)]
293#[repr(C)]
294pub struct TrackerSparqlConnection {
295 pub parent_instance: gobject::GObject,
296}
297
298impl ::std::fmt::Debug for TrackerSparqlConnection {
299 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
300 f.debug_struct(&format!("TrackerSparqlConnection @ {self:p}"))
301 .field("parent_instance", &self.parent_instance)
302 .finish()
303 }
304}
305
306#[derive(Copy, Clone)]
307#[repr(C)]
308pub struct TrackerSparqlCursor {
309 pub parent_instance: gobject::GObject,
310}
311
312impl ::std::fmt::Debug for TrackerSparqlCursor {
313 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
314 f.debug_struct(&format!("TrackerSparqlCursor @ {self:p}"))
315 .field("parent_instance", &self.parent_instance)
316 .finish()
317 }
318}
319
320#[derive(Copy, Clone)]
321#[repr(C)]
322pub struct TrackerSparqlStatement {
323 pub parent_instance: gobject::GObject,
324}
325
326impl ::std::fmt::Debug for TrackerSparqlStatement {
327 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
328 f.debug_struct(&format!("TrackerSparqlStatement @ {self:p}"))
329 .field("parent_instance", &self.parent_instance)
330 .finish()
331 }
332}
333
334extern "C" {
335
336 pub fn tracker_deserialize_flags_get_type() -> GType;
340
341 pub fn tracker_notifier_event_type_get_type() -> GType;
345
346 pub fn tracker_rdf_format_get_type() -> GType;
350
351 pub fn tracker_serialize_flags_get_type() -> GType;
355
356 pub fn tracker_sparql_error_get_type() -> GType;
360 pub fn tracker_sparql_error_quark() -> glib::GQuark;
361
362 pub fn tracker_sparql_connection_flags_get_type() -> GType;
366
367 pub fn tracker_notifier_event_get_type() -> GType;
371 pub fn tracker_notifier_event_get_event_type(event: *mut TrackerNotifierEvent) -> TrackerNotifierEventType;
372 pub fn tracker_notifier_event_get_id(event: *mut TrackerNotifierEvent) -> i64;
373 pub fn tracker_notifier_event_get_urn(event: *mut TrackerNotifierEvent) -> *const c_char;
374
375 #[cfg(feature = "v3_1")]
379 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
380 pub fn tracker_batch_get_type() -> GType;
381 #[cfg(feature = "v3_6")]
382 #[cfg_attr(docsrs, doc(cfg(feature = "v3_6")))]
383 pub fn tracker_batch_add_rdf(batch: *mut TrackerBatch, flags: TrackerDeserializeFlags, format: TrackerRdfFormat, default_graph: *const c_char, stream: *mut gio::GInputStream);
384 #[cfg(feature = "v3_1")]
385 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
386 pub fn tracker_batch_add_resource(batch: *mut TrackerBatch, graph: *const c_char, resource: *mut TrackerResource);
387 #[cfg(feature = "v3_1")]
388 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
389 pub fn tracker_batch_add_sparql(batch: *mut TrackerBatch, sparql: *const c_char);
390 #[cfg(feature = "v3_5")]
391 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
392 pub fn tracker_batch_add_statement(batch: *mut TrackerBatch, stmt: *mut TrackerSparqlStatement, ...);
393 #[cfg(feature = "v3_5")]
394 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
395 pub fn tracker_batch_add_statementv(batch: *mut TrackerBatch, stmt: *mut TrackerSparqlStatement, n_values: c_uint, variable_names: *mut *const c_char, values: *const gobject::GValue);
396 #[cfg(feature = "v3_1")]
397 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
398 pub fn tracker_batch_execute(batch: *mut TrackerBatch, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
399 #[cfg(feature = "v3_1")]
400 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
401 pub fn tracker_batch_execute_async(batch: *mut TrackerBatch, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
402 #[cfg(feature = "v3_1")]
403 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
404 pub fn tracker_batch_execute_finish(batch: *mut TrackerBatch, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
405 #[cfg(feature = "v3_1")]
406 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
407 pub fn tracker_batch_get_connection(batch: *mut TrackerBatch) -> *mut TrackerSparqlConnection;
408
409 pub fn tracker_endpoint_get_type() -> GType;
413 #[cfg(feature = "v3_7")]
414 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
415 pub fn tracker_endpoint_get_allowed_graphs(endpoint: *mut TrackerEndpoint) -> c_char;
416 #[cfg(feature = "v3_7")]
417 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
418 pub fn tracker_endpoint_get_allowed_services(endpoint: *mut TrackerEndpoint) -> c_char;
419 #[cfg(feature = "v3_7")]
420 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
421 pub fn tracker_endpoint_get_readonly(endpoint: *mut TrackerEndpoint) -> gboolean;
422 pub fn tracker_endpoint_get_sparql_connection(endpoint: *mut TrackerEndpoint) -> *mut TrackerSparqlConnection;
423 #[cfg(feature = "v3_7")]
424 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
425 pub fn tracker_endpoint_set_allowed_graphs(endpoint: *mut TrackerEndpoint, graphs: *const *const c_char);
426 #[cfg(feature = "v3_7")]
427 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
428 pub fn tracker_endpoint_set_allowed_services(endpoint: *mut TrackerEndpoint, services: *const *const c_char);
429 #[cfg(feature = "v3_7")]
430 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
431 pub fn tracker_endpoint_set_readonly(endpoint: *mut TrackerEndpoint, readonly: gboolean);
432
433 pub fn tracker_endpoint_dbus_get_type() -> GType;
437 pub fn tracker_endpoint_dbus_new(sparql_connection: *mut TrackerSparqlConnection, dbus_connection: *mut gio::GDBusConnection, object_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerEndpointDBus;
438
439 #[cfg(feature = "v3_1")]
443 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
444 pub fn tracker_endpoint_http_get_type() -> GType;
445 #[cfg(feature = "v3_1")]
446 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
447 pub fn tracker_endpoint_http_new(sparql_connection: *mut TrackerSparqlConnection, port: c_uint, certificate: *mut gio::GTlsCertificate, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerEndpointHttp;
448
449 pub fn tracker_namespace_manager_get_type() -> GType;
453 pub fn tracker_namespace_manager_new() -> *mut TrackerNamespaceManager;
454 pub fn tracker_namespace_manager_get_default() -> *mut TrackerNamespaceManager;
455 pub fn tracker_namespace_manager_add_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char, ns: *const c_char);
456 #[cfg(feature = "v3_3")]
457 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
458 pub fn tracker_namespace_manager_compress_uri(self_: *mut TrackerNamespaceManager, uri: *const c_char) -> *mut c_char;
459 pub fn tracker_namespace_manager_expand_uri(self_: *mut TrackerNamespaceManager, compact_uri: *const c_char) -> *mut c_char;
460 pub fn tracker_namespace_manager_foreach(self_: *mut TrackerNamespaceManager, func: glib::GHFunc, user_data: gpointer);
461 pub fn tracker_namespace_manager_has_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char) -> gboolean;
462 pub fn tracker_namespace_manager_lookup_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char) -> *const c_char;
463 pub fn tracker_namespace_manager_print_turtle(self_: *mut TrackerNamespaceManager) -> *mut c_char;
464
465 pub fn tracker_notifier_get_type() -> GType;
469 pub fn tracker_notifier_signal_subscribe(notifier: *mut TrackerNotifier, connection: *mut gio::GDBusConnection, service: *const c_char, object_path: *const c_char, graph: *const c_char) -> c_uint;
470 pub fn tracker_notifier_signal_unsubscribe(notifier: *mut TrackerNotifier, handler_id: c_uint);
471
472 pub fn tracker_resource_get_type() -> GType;
476 pub fn tracker_resource_new(identifier: *const c_char) -> *mut TrackerResource;
477 pub fn tracker_resource_deserialize(variant: *mut glib::GVariant) -> *mut TrackerResource;
478 pub fn tracker_resource_add_boolean(self_: *mut TrackerResource, property_uri: *const c_char, value: gboolean);
479 #[cfg(feature = "v3_2")]
480 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
481 pub fn tracker_resource_add_datetime(self_: *mut TrackerResource, property_uri: *const c_char, value: *mut glib::GDateTime);
482 pub fn tracker_resource_add_double(self_: *mut TrackerResource, property_uri: *const c_char, value: c_double);
483 pub fn tracker_resource_add_gvalue(self_: *mut TrackerResource, property_uri: *const c_char, value: *const gobject::GValue);
484 pub fn tracker_resource_add_int(self_: *mut TrackerResource, property_uri: *const c_char, value: c_int);
485 pub fn tracker_resource_add_int64(self_: *mut TrackerResource, property_uri: *const c_char, value: i64);
486 pub fn tracker_resource_add_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
487 pub fn tracker_resource_add_string(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
488 pub fn tracker_resource_add_take_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
489 pub fn tracker_resource_add_uri(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
490 pub fn tracker_resource_get_first_boolean(self_: *mut TrackerResource, property_uri: *const c_char) -> gboolean;
491 #[cfg(feature = "v3_2")]
492 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
493 pub fn tracker_resource_get_first_datetime(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut glib::GDateTime;
494 pub fn tracker_resource_get_first_double(self_: *mut TrackerResource, property_uri: *const c_char) -> c_double;
495 pub fn tracker_resource_get_first_int(self_: *mut TrackerResource, property_uri: *const c_char) -> c_int;
496 pub fn tracker_resource_get_first_int64(self_: *mut TrackerResource, property_uri: *const c_char) -> i64;
497 pub fn tracker_resource_get_first_relation(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut TrackerResource;
498 pub fn tracker_resource_get_first_string(self_: *mut TrackerResource, property_uri: *const c_char) -> *const c_char;
499 pub fn tracker_resource_get_first_uri(self_: *mut TrackerResource, property_uri: *const c_char) -> *const c_char;
500 pub fn tracker_resource_get_identifier(self_: *mut TrackerResource) -> *const c_char;
501 pub fn tracker_resource_get_properties(resource: *mut TrackerResource) -> *mut glib::GList;
502 #[cfg(feature = "v3_1")]
503 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
504 pub fn tracker_resource_get_property_overwrite(resource: *mut TrackerResource, property_uri: *const c_char) -> gboolean;
505 pub fn tracker_resource_get_values(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut glib::GList;
506 pub fn tracker_resource_identifier_compare_func(resource: *mut TrackerResource, identifier: *const c_char) -> c_int;
507 pub fn tracker_resource_print_jsonld(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager) -> *mut c_char;
508 #[cfg(feature = "v3_4")]
509 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
510 pub fn tracker_resource_print_rdf(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager, format: TrackerRdfFormat, graph: *const c_char) -> *mut c_char;
511 pub fn tracker_resource_print_sparql_update(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager, graph_id: *const c_char) -> *mut c_char;
512 pub fn tracker_resource_print_turtle(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager) -> *mut c_char;
513 pub fn tracker_resource_serialize(resource: *mut TrackerResource) -> *mut glib::GVariant;
514 pub fn tracker_resource_set_boolean(self_: *mut TrackerResource, property_uri: *const c_char, value: gboolean);
515 #[cfg(feature = "v3_2")]
516 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
517 pub fn tracker_resource_set_datetime(self_: *mut TrackerResource, property_uri: *const c_char, value: *mut glib::GDateTime);
518 pub fn tracker_resource_set_double(self_: *mut TrackerResource, property_uri: *const c_char, value: c_double);
519 pub fn tracker_resource_set_gvalue(self_: *mut TrackerResource, property_uri: *const c_char, value: *const gobject::GValue);
520 pub fn tracker_resource_set_identifier(self_: *mut TrackerResource, identifier: *const c_char);
521 pub fn tracker_resource_set_int(self_: *mut TrackerResource, property_uri: *const c_char, value: c_int);
522 pub fn tracker_resource_set_int64(self_: *mut TrackerResource, property_uri: *const c_char, value: i64);
523 pub fn tracker_resource_set_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
524 pub fn tracker_resource_set_string(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
525 pub fn tracker_resource_set_take_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
526 pub fn tracker_resource_set_uri(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
527
528 pub fn tracker_sparql_connection_get_type() -> GType;
532 pub fn tracker_sparql_connection_bus_new(service_name: *const c_char, object_path: *const c_char, dbus_connection: *mut gio::GDBusConnection, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
533 #[cfg(feature = "v3_1")]
534 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
535 pub fn tracker_sparql_connection_bus_new_finish(result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
536 pub fn tracker_sparql_connection_new(flags: TrackerSparqlConnectionFlags, store: *mut gio::GFile, ontology: *mut gio::GFile, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
537 pub fn tracker_sparql_connection_new_finish(result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
538 pub fn tracker_sparql_connection_remote_new(uri_base: *const c_char) -> *mut TrackerSparqlConnection;
539 #[cfg(feature = "v3_1")]
540 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
541 pub fn tracker_sparql_connection_bus_new_async(service_name: *const c_char, object_path: *const c_char, dbus_connection: *mut gio::GDBusConnection, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
542 pub fn tracker_sparql_connection_new_async(flags: TrackerSparqlConnectionFlags, store: *mut gio::GFile, ontology: *mut gio::GFile, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
543 pub fn tracker_sparql_connection_close(connection: *mut TrackerSparqlConnection);
544 pub fn tracker_sparql_connection_close_async(connection: *mut TrackerSparqlConnection, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
545 pub fn tracker_sparql_connection_close_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
546 #[cfg(feature = "v3_1")]
547 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
548 pub fn tracker_sparql_connection_create_batch(connection: *mut TrackerSparqlConnection) -> *mut TrackerBatch;
549 pub fn tracker_sparql_connection_create_notifier(connection: *mut TrackerSparqlConnection) -> *mut TrackerNotifier;
550 #[cfg(feature = "v3_4")]
551 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
552 pub fn tracker_sparql_connection_deserialize_async(connection: *mut TrackerSparqlConnection, flags: TrackerDeserializeFlags, format: TrackerRdfFormat, default_graph: *const c_char, stream: *mut gio::GInputStream, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
553 #[cfg(feature = "v3_4")]
554 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
555 pub fn tracker_sparql_connection_deserialize_finish(connection: *mut TrackerSparqlConnection, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
556 pub fn tracker_sparql_connection_get_namespace_manager(connection: *mut TrackerSparqlConnection) -> *mut TrackerNamespaceManager;
557 #[cfg(feature = "v3_3")]
558 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
559 pub fn tracker_sparql_connection_load_statement_from_gresource(connection: *mut TrackerSparqlConnection, resource_path: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlStatement;
560 #[cfg(feature = "v3_3")]
561 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
562 pub fn tracker_sparql_connection_map_connection(connection: *mut TrackerSparqlConnection, handle_name: *const c_char, service_connection: *mut TrackerSparqlConnection);
563 pub fn tracker_sparql_connection_query(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
564 pub fn tracker_sparql_connection_query_async(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
565 pub fn tracker_sparql_connection_query_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
566 pub fn tracker_sparql_connection_query_statement(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlStatement;
567 #[cfg(feature = "v3_3")]
568 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
569 pub fn tracker_sparql_connection_serialize_async(connection: *mut TrackerSparqlConnection, flags: TrackerSerializeFlags, format: TrackerRdfFormat, query: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
570 #[cfg(feature = "v3_3")]
571 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
572 pub fn tracker_sparql_connection_serialize_finish(connection: *mut TrackerSparqlConnection, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
573 pub fn tracker_sparql_connection_update(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError);
574 pub fn tracker_sparql_connection_update_array_async(connection: *mut TrackerSparqlConnection, sparql: *mut *mut c_char, sparql_length: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
575 pub fn tracker_sparql_connection_update_array_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
576 pub fn tracker_sparql_connection_update_async(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
577 pub fn tracker_sparql_connection_update_blank(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut glib::GVariant;
578 pub fn tracker_sparql_connection_update_blank_async(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
579 pub fn tracker_sparql_connection_update_blank_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut glib::GVariant;
580 pub fn tracker_sparql_connection_update_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
581 #[cfg(feature = "v3_1")]
582 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
583 pub fn tracker_sparql_connection_update_resource(connection: *mut TrackerSparqlConnection, graph: *const c_char, resource: *mut TrackerResource, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
584 #[cfg(feature = "v3_1")]
585 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
586 pub fn tracker_sparql_connection_update_resource_async(connection: *mut TrackerSparqlConnection, graph: *const c_char, resource: *mut TrackerResource, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
587 #[cfg(feature = "v3_1")]
588 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
589 pub fn tracker_sparql_connection_update_resource_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
590 #[cfg(feature = "v3_5")]
591 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
592 pub fn tracker_sparql_connection_update_statement(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlStatement;
593
594 pub fn tracker_sparql_cursor_get_type() -> GType;
598 pub fn tracker_sparql_cursor_close(cursor: *mut TrackerSparqlCursor);
599 pub fn tracker_sparql_cursor_get_boolean(cursor: *mut TrackerSparqlCursor, column: c_int) -> gboolean;
600 pub fn tracker_sparql_cursor_get_connection(cursor: *mut TrackerSparqlCursor) -> *mut TrackerSparqlConnection;
601 #[cfg(feature = "v3_2")]
602 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
603 pub fn tracker_sparql_cursor_get_datetime(cursor: *mut TrackerSparqlCursor, column: c_int) -> *mut glib::GDateTime;
604 pub fn tracker_sparql_cursor_get_double(cursor: *mut TrackerSparqlCursor, column: c_int) -> c_double;
605 pub fn tracker_sparql_cursor_get_integer(cursor: *mut TrackerSparqlCursor, column: c_int) -> i64;
606 #[cfg(feature = "v3_7")]
607 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
608 pub fn tracker_sparql_cursor_get_langstring(cursor: *mut TrackerSparqlCursor, column: c_int, langtag: *mut *const c_char, length: *mut c_long) -> *const c_char;
609 pub fn tracker_sparql_cursor_get_n_columns(cursor: *mut TrackerSparqlCursor) -> c_int;
610 pub fn tracker_sparql_cursor_get_string(cursor: *mut TrackerSparqlCursor, column: c_int, length: *mut c_long) -> *const c_char;
611 pub fn tracker_sparql_cursor_get_value_type(cursor: *mut TrackerSparqlCursor, column: c_int) -> TrackerSparqlValueType;
612 pub fn tracker_sparql_cursor_get_variable_name(cursor: *mut TrackerSparqlCursor, column: c_int) -> *const c_char;
613 pub fn tracker_sparql_cursor_is_bound(cursor: *mut TrackerSparqlCursor, column: c_int) -> gboolean;
614 pub fn tracker_sparql_cursor_next(cursor: *mut TrackerSparqlCursor, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
615 pub fn tracker_sparql_cursor_next_async(cursor: *mut TrackerSparqlCursor, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
616 pub fn tracker_sparql_cursor_next_finish(cursor: *mut TrackerSparqlCursor, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
617 pub fn tracker_sparql_cursor_rewind(cursor: *mut TrackerSparqlCursor);
618
619 pub fn tracker_sparql_statement_get_type() -> GType;
623 pub fn tracker_sparql_statement_bind_boolean(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: gboolean);
624 #[cfg(feature = "v3_2")]
625 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
626 pub fn tracker_sparql_statement_bind_datetime(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: *mut glib::GDateTime);
627 pub fn tracker_sparql_statement_bind_double(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: c_double);
628 pub fn tracker_sparql_statement_bind_int(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: i64);
629 #[cfg(feature = "v3_7")]
630 #[cfg_attr(docsrs, doc(cfg(feature = "v3_7")))]
631 pub fn tracker_sparql_statement_bind_langstring(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: *const c_char, langtag: *const c_char);
632 pub fn tracker_sparql_statement_bind_string(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: *const c_char);
633 pub fn tracker_sparql_statement_clear_bindings(stmt: *mut TrackerSparqlStatement);
634 pub fn tracker_sparql_statement_execute(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
635 pub fn tracker_sparql_statement_execute_async(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
636 pub fn tracker_sparql_statement_execute_finish(stmt: *mut TrackerSparqlStatement, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
637 pub fn tracker_sparql_statement_get_connection(stmt: *mut TrackerSparqlStatement) -> *mut TrackerSparqlConnection;
638 pub fn tracker_sparql_statement_get_sparql(stmt: *mut TrackerSparqlStatement) -> *const c_char;
639 #[cfg(feature = "v3_3")]
640 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
641 pub fn tracker_sparql_statement_serialize_async(stmt: *mut TrackerSparqlStatement, flags: TrackerSerializeFlags, format: TrackerRdfFormat, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
642 #[cfg(feature = "v3_3")]
643 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
644 pub fn tracker_sparql_statement_serialize_finish(stmt: *mut TrackerSparqlStatement, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
645 #[cfg(feature = "v3_5")]
646 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
647 pub fn tracker_sparql_statement_update(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
648 #[cfg(feature = "v3_5")]
649 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
650 pub fn tracker_sparql_statement_update_async(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
651 #[cfg(feature = "v3_5")]
652 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
653 pub fn tracker_sparql_statement_update_finish(stmt: *mut TrackerSparqlStatement, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
654
655 pub fn tracker_check_version(required_major: c_uint, required_minor: c_uint, required_micro: c_uint) -> *const c_char;
659 pub fn tracker_sparql_escape_string(literal: *const c_char) -> *mut c_char;
660 pub fn tracker_sparql_escape_uri(uri: *const c_char) -> *mut c_char;
661 pub fn tracker_sparql_escape_uri_printf(format: *const c_char, ...) -> *mut c_char;
662 pub fn tracker_sparql_get_ontology_nepomuk() -> *mut gio::GFile;
664 pub fn tracker_sparql_get_uuid_urn() -> *mut c_char;
665
666}