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_PREFIX_DC: &[u8] = b"http://purl.org/dc/elements/1.1/\0";
74pub const TRACKER_PREFIX_MFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/mfo#\0";
75pub const TRACKER_PREFIX_NAO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nao#\0";
76pub const TRACKER_PREFIX_NCO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nco#\0";
77pub const TRACKER_PREFIX_NFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nfo#\0";
78pub const TRACKER_PREFIX_NIE: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nie#\0";
79pub const TRACKER_PREFIX_NMM: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nmm#\0";
80pub const TRACKER_PREFIX_NRL: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/nrl#\0";
81pub const TRACKER_PREFIX_OSINFO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/osinfo#\0";
82pub const TRACKER_PREFIX_RDF: &[u8] = b"http://www.w3.org/1999/02/22-rdf-syntax-ns#\0";
83pub const TRACKER_PREFIX_RDFS: &[u8] = b"http://www.w3.org/2000/01/rdf-schema#\0";
84pub const TRACKER_PREFIX_SLO: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/slo#\0";
85pub const TRACKER_PREFIX_TRACKER: &[u8] = b"http://tracker.api.gnome.org/ontology/v3/tracker#\0";
86pub const TRACKER_PREFIX_XSD: &[u8] = b"http://www.w3.org/2001/XMLSchema#\0";
87
88pub type TrackerSparqlConnectionFlags = c_uint;
90pub const TRACKER_SPARQL_CONNECTION_FLAGS_NONE: TrackerSparqlConnectionFlags = 0;
91pub const TRACKER_SPARQL_CONNECTION_FLAGS_READONLY: TrackerSparqlConnectionFlags = 1;
92pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STEMMER: TrackerSparqlConnectionFlags = 2;
93pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_UNACCENT: TrackerSparqlConnectionFlags = 4;
94pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_ENABLE_STOP_WORDS: TrackerSparqlConnectionFlags = 8;
95pub const TRACKER_SPARQL_CONNECTION_FLAGS_FTS_IGNORE_NUMBERS: TrackerSparqlConnectionFlags = 16;
96pub const TRACKER_SPARQL_CONNECTION_FLAGS_ANONYMOUS_BNODES: TrackerSparqlConnectionFlags = 32;
97
98#[repr(C)]
100#[allow(dead_code)]
101pub struct _TrackerBatchClass {
102 _data: [u8; 0],
103 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
104}
105
106pub type TrackerBatchClass = _TrackerBatchClass;
107
108#[repr(C)]
109#[allow(dead_code)]
110pub struct _TrackerEndpointClass {
111 _data: [u8; 0],
112 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
113}
114
115pub type TrackerEndpointClass = _TrackerEndpointClass;
116
117#[derive(Copy, Clone)]
118#[repr(C)]
119pub struct TrackerNamespaceManagerClass {
120 pub parent_class: gobject::GObjectClass,
121}
122
123impl ::std::fmt::Debug for TrackerNamespaceManagerClass {
124 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
125 f.debug_struct(&format!("TrackerNamespaceManagerClass @ {self:p}"))
126 .field("parent_class", &self.parent_class)
127 .finish()
128 }
129}
130
131#[repr(C)]
132#[allow(dead_code)]
133pub struct _TrackerNotifierClass {
134 _data: [u8; 0],
135 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
136}
137
138pub type TrackerNotifierClass = _TrackerNotifierClass;
139
140#[repr(C)]
141#[allow(dead_code)]
142pub struct TrackerNotifierEvent {
143 _data: [u8; 0],
144 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
145}
146
147impl ::std::fmt::Debug for TrackerNotifierEvent {
148 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
149 f.debug_struct(&format!("TrackerNotifierEvent @ {self:p}"))
150 .finish()
151 }
152}
153
154#[repr(C)]
155#[allow(dead_code)]
156pub struct _TrackerResourceClass {
157 _data: [u8; 0],
158 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
159}
160
161pub type TrackerResourceClass = _TrackerResourceClass;
162
163#[repr(C)]
164#[allow(dead_code)]
165pub struct _TrackerSparqlConnectionClass {
166 _data: [u8; 0],
167 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
168}
169
170pub type TrackerSparqlConnectionClass = _TrackerSparqlConnectionClass;
171
172#[repr(C)]
173#[allow(dead_code)]
174pub struct _TrackerSparqlCursorClass {
175 _data: [u8; 0],
176 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
177}
178
179pub type TrackerSparqlCursorClass = _TrackerSparqlCursorClass;
180
181#[repr(C)]
182#[allow(dead_code)]
183pub struct _TrackerSparqlStatementClass {
184 _data: [u8; 0],
185 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
186}
187
188pub type TrackerSparqlStatementClass = _TrackerSparqlStatementClass;
189
190#[derive(Copy, Clone)]
192#[repr(C)]
193pub struct TrackerBatch {
194 pub parent_instance: gobject::GObject,
195}
196
197impl ::std::fmt::Debug for TrackerBatch {
198 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
199 f.debug_struct(&format!("TrackerBatch @ {self:p}"))
200 .field("parent_instance", &self.parent_instance)
201 .finish()
202 }
203}
204
205#[derive(Copy, Clone)]
206#[repr(C)]
207pub struct TrackerEndpoint {
208 pub parent_instance: gobject::GObject,
209}
210
211impl ::std::fmt::Debug for TrackerEndpoint {
212 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
213 f.debug_struct(&format!("TrackerEndpoint @ {self:p}"))
214 .field("parent_instance", &self.parent_instance)
215 .finish()
216 }
217}
218
219#[repr(C)]
220#[allow(dead_code)]
221pub struct TrackerEndpointDBus {
222 _data: [u8; 0],
223 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
224}
225
226impl ::std::fmt::Debug for TrackerEndpointDBus {
227 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
228 f.debug_struct(&format!("TrackerEndpointDBus @ {self:p}"))
229 .finish()
230 }
231}
232
233#[repr(C)]
234#[allow(dead_code)]
235pub struct TrackerEndpointHttp {
236 _data: [u8; 0],
237 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
238}
239
240impl ::std::fmt::Debug for TrackerEndpointHttp {
241 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
242 f.debug_struct(&format!("TrackerEndpointHttp @ {self:p}"))
243 .finish()
244 }
245}
246
247#[repr(C)]
248#[allow(dead_code)]
249pub struct TrackerNamespaceManager {
250 _data: [u8; 0],
251 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
252}
253
254impl ::std::fmt::Debug for TrackerNamespaceManager {
255 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
256 f.debug_struct(&format!("TrackerNamespaceManager @ {self:p}"))
257 .finish()
258 }
259}
260
261#[derive(Copy, Clone)]
262#[repr(C)]
263pub struct TrackerNotifier {
264 pub parent_instance: gobject::GObject,
265}
266
267impl ::std::fmt::Debug for TrackerNotifier {
268 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
269 f.debug_struct(&format!("TrackerNotifier @ {self:p}"))
270 .field("parent_instance", &self.parent_instance)
271 .finish()
272 }
273}
274
275#[derive(Copy, Clone)]
276#[repr(C)]
277pub struct TrackerResource {
278 pub parent_instance: gobject::GObject,
279}
280
281impl ::std::fmt::Debug for TrackerResource {
282 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
283 f.debug_struct(&format!("TrackerResource @ {self:p}"))
284 .field("parent_instance", &self.parent_instance)
285 .finish()
286 }
287}
288
289#[derive(Copy, Clone)]
290#[repr(C)]
291pub struct TrackerSparqlConnection {
292 pub parent_instance: gobject::GObject,
293}
294
295impl ::std::fmt::Debug for TrackerSparqlConnection {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297 f.debug_struct(&format!("TrackerSparqlConnection @ {self:p}"))
298 .field("parent_instance", &self.parent_instance)
299 .finish()
300 }
301}
302
303#[derive(Copy, Clone)]
304#[repr(C)]
305pub struct TrackerSparqlCursor {
306 pub parent_instance: gobject::GObject,
307}
308
309impl ::std::fmt::Debug for TrackerSparqlCursor {
310 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
311 f.debug_struct(&format!("TrackerSparqlCursor @ {self:p}"))
312 .field("parent_instance", &self.parent_instance)
313 .finish()
314 }
315}
316
317#[derive(Copy, Clone)]
318#[repr(C)]
319pub struct TrackerSparqlStatement {
320 pub parent_instance: gobject::GObject,
321}
322
323impl ::std::fmt::Debug for TrackerSparqlStatement {
324 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
325 f.debug_struct(&format!("TrackerSparqlStatement @ {self:p}"))
326 .field("parent_instance", &self.parent_instance)
327 .finish()
328 }
329}
330
331extern "C" {
332
333 pub fn tracker_notifier_event_get_type() -> GType;
337 pub fn tracker_notifier_event_get_event_type(event: *mut TrackerNotifierEvent) -> TrackerNotifierEventType;
338 pub fn tracker_notifier_event_get_id(event: *mut TrackerNotifierEvent) -> i64;
339 pub fn tracker_notifier_event_get_urn(event: *mut TrackerNotifierEvent) -> *const c_char;
340
341 pub fn tracker_batch_get_type() -> GType;
345 #[cfg(feature = "v3_1")]
346 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
347 pub fn tracker_batch_add_resource(batch: *mut TrackerBatch, graph: *const c_char, resource: *mut TrackerResource);
348 #[cfg(feature = "v3_1")]
349 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
350 pub fn tracker_batch_add_sparql(batch: *mut TrackerBatch, sparql: *const c_char);
351 #[cfg(feature = "v3_5")]
352 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
353 pub fn tracker_batch_add_statement(batch: *mut TrackerBatch, stmt: *mut TrackerSparqlStatement, ...);
354 #[cfg(feature = "v3_5")]
355 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
356 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);
357 #[cfg(feature = "v3_1")]
358 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
359 pub fn tracker_batch_execute(batch: *mut TrackerBatch, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
360 #[cfg(feature = "v3_1")]
361 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
362 pub fn tracker_batch_execute_async(batch: *mut TrackerBatch, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
363 #[cfg(feature = "v3_1")]
364 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
365 pub fn tracker_batch_execute_finish(batch: *mut TrackerBatch, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
366 pub fn tracker_batch_get_connection(batch: *mut TrackerBatch) -> *mut TrackerSparqlConnection;
367
368 pub fn tracker_endpoint_get_type() -> GType;
372 pub fn tracker_endpoint_get_sparql_connection(endpoint: *mut TrackerEndpoint) -> *mut TrackerSparqlConnection;
373
374 pub fn tracker_endpoint_dbus_get_type() -> GType;
378 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;
379
380 pub fn tracker_endpoint_http_get_type() -> GType;
384 #[cfg(feature = "v3_1")]
385 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
386 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;
387
388 pub fn tracker_namespace_manager_get_type() -> GType;
392 pub fn tracker_namespace_manager_new() -> *mut TrackerNamespaceManager;
393 pub fn tracker_namespace_manager_get_default() -> *mut TrackerNamespaceManager;
394 pub fn tracker_namespace_manager_add_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char, ns: *const c_char);
395 #[cfg(feature = "v3_3")]
396 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
397 pub fn tracker_namespace_manager_compress_uri(self_: *mut TrackerNamespaceManager, uri: *const c_char) -> *mut c_char;
398 pub fn tracker_namespace_manager_expand_uri(self_: *mut TrackerNamespaceManager, compact_uri: *const c_char) -> *mut c_char;
399 pub fn tracker_namespace_manager_foreach(self_: *mut TrackerNamespaceManager, func: glib::GHFunc, user_data: gpointer);
400 pub fn tracker_namespace_manager_has_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char) -> gboolean;
401 pub fn tracker_namespace_manager_lookup_prefix(self_: *mut TrackerNamespaceManager, prefix: *const c_char) -> *const c_char;
402 pub fn tracker_namespace_manager_print_turtle(self_: *mut TrackerNamespaceManager) -> *mut c_char;
403
404 pub fn tracker_notifier_get_type() -> GType;
408 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;
409 pub fn tracker_notifier_signal_unsubscribe(notifier: *mut TrackerNotifier, handler_id: c_uint);
410
411 pub fn tracker_resource_get_type() -> GType;
415 pub fn tracker_resource_new(identifier: *const c_char) -> *mut TrackerResource;
416 pub fn tracker_resource_deserialize(variant: *mut glib::GVariant) -> *mut TrackerResource;
417 pub fn tracker_resource_add_boolean(self_: *mut TrackerResource, property_uri: *const c_char, value: gboolean);
418 #[cfg(feature = "v3_2")]
419 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
420 pub fn tracker_resource_add_datetime(self_: *mut TrackerResource, property_uri: *const c_char, value: *mut glib::GDateTime);
421 pub fn tracker_resource_add_double(self_: *mut TrackerResource, property_uri: *const c_char, value: c_double);
422 pub fn tracker_resource_add_gvalue(self_: *mut TrackerResource, property_uri: *const c_char, value: *const gobject::GValue);
423 pub fn tracker_resource_add_int(self_: *mut TrackerResource, property_uri: *const c_char, value: c_int);
424 pub fn tracker_resource_add_int64(self_: *mut TrackerResource, property_uri: *const c_char, value: i64);
425 pub fn tracker_resource_add_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
426 pub fn tracker_resource_add_string(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
427 pub fn tracker_resource_add_take_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
428 pub fn tracker_resource_add_uri(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
429 pub fn tracker_resource_get_first_boolean(self_: *mut TrackerResource, property_uri: *const c_char) -> gboolean;
430 #[cfg(feature = "v3_2")]
431 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
432 pub fn tracker_resource_get_first_datetime(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut glib::GDateTime;
433 pub fn tracker_resource_get_first_double(self_: *mut TrackerResource, property_uri: *const c_char) -> c_double;
434 pub fn tracker_resource_get_first_int(self_: *mut TrackerResource, property_uri: *const c_char) -> c_int;
435 pub fn tracker_resource_get_first_int64(self_: *mut TrackerResource, property_uri: *const c_char) -> i64;
436 pub fn tracker_resource_get_first_relation(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut TrackerResource;
437 pub fn tracker_resource_get_first_string(self_: *mut TrackerResource, property_uri: *const c_char) -> *const c_char;
438 pub fn tracker_resource_get_first_uri(self_: *mut TrackerResource, property_uri: *const c_char) -> *const c_char;
439 pub fn tracker_resource_get_identifier(self_: *mut TrackerResource) -> *const c_char;
440 pub fn tracker_resource_get_properties(resource: *mut TrackerResource) -> *mut glib::GList;
441 #[cfg(feature = "v3_1")]
442 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
443 pub fn tracker_resource_get_property_overwrite(resource: *mut TrackerResource, property_uri: *const c_char) -> gboolean;
444 pub fn tracker_resource_get_values(self_: *mut TrackerResource, property_uri: *const c_char) -> *mut glib::GList;
445 pub fn tracker_resource_identifier_compare_func(resource: *mut TrackerResource, identifier: *const c_char) -> c_int;
446 pub fn tracker_resource_print_jsonld(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager) -> *mut c_char;
447 #[cfg(feature = "v3_4")]
448 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
449 pub fn tracker_resource_print_rdf(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager, format: TrackerRdfFormat, graph: *const c_char) -> *mut c_char;
450 pub fn tracker_resource_print_sparql_update(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager, graph_id: *const c_char) -> *mut c_char;
451 pub fn tracker_resource_print_turtle(self_: *mut TrackerResource, namespaces: *mut TrackerNamespaceManager) -> *mut c_char;
452 pub fn tracker_resource_serialize(resource: *mut TrackerResource) -> *mut glib::GVariant;
453 pub fn tracker_resource_set_boolean(self_: *mut TrackerResource, property_uri: *const c_char, value: gboolean);
454 #[cfg(feature = "v3_2")]
455 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
456 pub fn tracker_resource_set_datetime(self_: *mut TrackerResource, property_uri: *const c_char, value: *mut glib::GDateTime);
457 pub fn tracker_resource_set_double(self_: *mut TrackerResource, property_uri: *const c_char, value: c_double);
458 pub fn tracker_resource_set_gvalue(self_: *mut TrackerResource, property_uri: *const c_char, value: *const gobject::GValue);
459 pub fn tracker_resource_set_identifier(self_: *mut TrackerResource, identifier: *const c_char);
460 pub fn tracker_resource_set_int(self_: *mut TrackerResource, property_uri: *const c_char, value: c_int);
461 pub fn tracker_resource_set_int64(self_: *mut TrackerResource, property_uri: *const c_char, value: i64);
462 pub fn tracker_resource_set_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
463 pub fn tracker_resource_set_string(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
464 pub fn tracker_resource_set_take_relation(self_: *mut TrackerResource, property_uri: *const c_char, resource: *mut TrackerResource);
465 pub fn tracker_resource_set_uri(self_: *mut TrackerResource, property_uri: *const c_char, value: *const c_char);
466
467 pub fn tracker_sparql_connection_get_type() -> GType;
471 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;
472 #[cfg(feature = "v3_1")]
473 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
474 pub fn tracker_sparql_connection_bus_new_finish(result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
475 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;
476 pub fn tracker_sparql_connection_new_finish(result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlConnection;
477 pub fn tracker_sparql_connection_remote_new(uri_base: *const c_char) -> *mut TrackerSparqlConnection;
478 #[cfg(feature = "v3_1")]
479 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
480 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);
481 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);
482 pub fn tracker_sparql_connection_close(connection: *mut TrackerSparqlConnection);
483 pub fn tracker_sparql_connection_close_async(connection: *mut TrackerSparqlConnection, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
484 pub fn tracker_sparql_connection_close_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
485 pub fn tracker_sparql_connection_create_batch(connection: *mut TrackerSparqlConnection) -> *mut TrackerBatch;
486 pub fn tracker_sparql_connection_create_notifier(connection: *mut TrackerSparqlConnection) -> *mut TrackerNotifier;
487 #[cfg(feature = "v3_4")]
488 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
489 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);
490 #[cfg(feature = "v3_4")]
491 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
492 pub fn tracker_sparql_connection_deserialize_finish(connection: *mut TrackerSparqlConnection, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
493 pub fn tracker_sparql_connection_get_namespace_manager(connection: *mut TrackerSparqlConnection) -> *mut TrackerNamespaceManager;
494 #[cfg(feature = "v3_3")]
495 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
496 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;
497 #[cfg(feature = "v3_3")]
498 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
499 pub fn tracker_sparql_connection_map_connection(connection: *mut TrackerSparqlConnection, handle_name: *const c_char, service_connection: *mut TrackerSparqlConnection);
500 pub fn tracker_sparql_connection_query(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
501 pub fn tracker_sparql_connection_query_async(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
502 pub fn tracker_sparql_connection_query_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
503 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;
504 #[cfg(feature = "v3_3")]
505 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
506 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);
507 #[cfg(feature = "v3_3")]
508 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
509 pub fn tracker_sparql_connection_serialize_finish(connection: *mut TrackerSparqlConnection, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
510 pub fn tracker_sparql_connection_update(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError);
511 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);
512 pub fn tracker_sparql_connection_update_array_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
513 pub fn tracker_sparql_connection_update_async(connection: *mut TrackerSparqlConnection, sparql: *const c_char, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
514 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;
515 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);
516 pub fn tracker_sparql_connection_update_blank_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut glib::GVariant;
517 pub fn tracker_sparql_connection_update_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
518 #[cfg(feature = "v3_1")]
519 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
520 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;
521 #[cfg(feature = "v3_1")]
522 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
523 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);
524 #[cfg(feature = "v3_1")]
525 #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
526 pub fn tracker_sparql_connection_update_resource_finish(connection: *mut TrackerSparqlConnection, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
527 #[cfg(feature = "v3_5")]
528 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
529 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;
530
531 pub fn tracker_sparql_cursor_get_type() -> GType;
535 pub fn tracker_sparql_cursor_close(cursor: *mut TrackerSparqlCursor);
536 pub fn tracker_sparql_cursor_get_boolean(cursor: *mut TrackerSparqlCursor, column: c_int) -> gboolean;
537 pub fn tracker_sparql_cursor_get_connection(cursor: *mut TrackerSparqlCursor) -> *mut TrackerSparqlConnection;
538 #[cfg(feature = "v3_2")]
539 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
540 pub fn tracker_sparql_cursor_get_datetime(cursor: *mut TrackerSparqlCursor, column: c_int) -> *mut glib::GDateTime;
541 pub fn tracker_sparql_cursor_get_double(cursor: *mut TrackerSparqlCursor, column: c_int) -> c_double;
542 pub fn tracker_sparql_cursor_get_integer(cursor: *mut TrackerSparqlCursor, column: c_int) -> i64;
543 pub fn tracker_sparql_cursor_get_n_columns(cursor: *mut TrackerSparqlCursor) -> c_int;
544 pub fn tracker_sparql_cursor_get_string(cursor: *mut TrackerSparqlCursor, column: c_int, length: *mut c_long) -> *const c_char;
545 pub fn tracker_sparql_cursor_get_value_type(cursor: *mut TrackerSparqlCursor, column: c_int) -> TrackerSparqlValueType;
546 pub fn tracker_sparql_cursor_get_variable_name(cursor: *mut TrackerSparqlCursor, column: c_int) -> *const c_char;
547 pub fn tracker_sparql_cursor_is_bound(cursor: *mut TrackerSparqlCursor, column: c_int) -> gboolean;
548 pub fn tracker_sparql_cursor_next(cursor: *mut TrackerSparqlCursor, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
549 pub fn tracker_sparql_cursor_next_async(cursor: *mut TrackerSparqlCursor, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
550 pub fn tracker_sparql_cursor_next_finish(cursor: *mut TrackerSparqlCursor, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
551 pub fn tracker_sparql_cursor_rewind(cursor: *mut TrackerSparqlCursor);
552
553 pub fn tracker_sparql_statement_get_type() -> GType;
557 pub fn tracker_sparql_statement_bind_boolean(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: gboolean);
558 #[cfg(feature = "v3_2")]
559 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
560 pub fn tracker_sparql_statement_bind_datetime(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: *mut glib::GDateTime);
561 pub fn tracker_sparql_statement_bind_double(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: c_double);
562 pub fn tracker_sparql_statement_bind_int(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: i64);
563 pub fn tracker_sparql_statement_bind_string(stmt: *mut TrackerSparqlStatement, name: *const c_char, value: *const c_char);
564 pub fn tracker_sparql_statement_clear_bindings(stmt: *mut TrackerSparqlStatement);
565 pub fn tracker_sparql_statement_execute(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
566 pub fn tracker_sparql_statement_execute_async(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
567 pub fn tracker_sparql_statement_execute_finish(stmt: *mut TrackerSparqlStatement, res: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut TrackerSparqlCursor;
568 pub fn tracker_sparql_statement_get_connection(stmt: *mut TrackerSparqlStatement) -> *mut TrackerSparqlConnection;
569 pub fn tracker_sparql_statement_get_sparql(stmt: *mut TrackerSparqlStatement) -> *const c_char;
570 #[cfg(feature = "v3_3")]
571 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
572 pub fn tracker_sparql_statement_serialize_async(stmt: *mut TrackerSparqlStatement, flags: TrackerSerializeFlags, format: TrackerRdfFormat, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
573 #[cfg(feature = "v3_3")]
574 #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
575 pub fn tracker_sparql_statement_serialize_finish(stmt: *mut TrackerSparqlStatement, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
576 #[cfg(feature = "v3_5")]
577 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
578 pub fn tracker_sparql_statement_update(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> gboolean;
579 #[cfg(feature = "v3_5")]
580 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
581 pub fn tracker_sparql_statement_update_async(stmt: *mut TrackerSparqlStatement, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
582 #[cfg(feature = "v3_5")]
583 #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
584 pub fn tracker_sparql_statement_update_finish(stmt: *mut TrackerSparqlStatement, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
585
586 pub fn tracker_check_version(required_major: c_uint, required_minor: c_uint, required_micro: c_uint) -> *const c_char;
590 pub fn tracker_sparql_error_quark() -> glib::GQuark;
591 pub fn tracker_sparql_escape_string(literal: *const c_char) -> *mut c_char;
592 pub fn tracker_sparql_escape_uri(uri: *const c_char) -> *mut c_char;
593 pub fn tracker_sparql_escape_uri_printf(format: *const c_char, ...) -> *mut c_char;
594 pub fn tracker_sparql_get_ontology_nepomuk() -> *mut gio::GFile;
596 pub fn tracker_sparql_get_uuid_urn() -> *mut c_char;
597
598}