tracker/auto/
sparql_connection.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from
3// from gir-files (https://github.com/gtk-rs/gir-files.git)
4// DO NOT EDIT
5#![allow(deprecated)]
6
7#[cfg(feature = "v3_4")]
8#[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
9use crate::DeserializeFlags;
10use crate::{
11    ffi, NamespaceManager, Notifier, SparqlConnectionFlags, SparqlCursor, SparqlStatement,
12};
13#[cfg(feature = "v3_1")]
14#[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
15use crate::{Batch, Resource};
16#[cfg(feature = "v3_3")]
17#[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
18use crate::{RdfFormat, SerializeFlags};
19use glib::{prelude::*, translate::*};
20use std::{boxed::Box as Box_, pin::Pin};
21
22glib::wrapper! {
23    #[doc(alias = "TrackerSparqlConnection")]
24    pub struct SparqlConnection(Object<ffi::TrackerSparqlConnection, ffi::TrackerSparqlConnectionClass>);
25
26    match fn {
27        type_ => || ffi::tracker_sparql_connection_get_type(),
28    }
29}
30
31impl SparqlConnection {
32    #[doc(alias = "tracker_sparql_connection_bus_new")]
33    pub fn bus_new(
34        service_name: &str,
35        object_path: Option<&str>,
36        dbus_connection: Option<&gio::DBusConnection>,
37    ) -> Result<SparqlConnection, glib::Error> {
38        assert_initialized_main_thread!();
39        unsafe {
40            let mut error = std::ptr::null_mut();
41            let ret = ffi::tracker_sparql_connection_bus_new(
42                service_name.to_glib_none().0,
43                object_path.to_glib_none().0,
44                dbus_connection.to_glib_none().0,
45                &mut error,
46            );
47            if error.is_null() {
48                Ok(from_glib_full(ret))
49            } else {
50                Err(from_glib_full(error))
51            }
52        }
53    }
54
55    #[doc(alias = "tracker_sparql_connection_new")]
56    pub fn new(
57        flags: SparqlConnectionFlags,
58        store: Option<&impl IsA<gio::File>>,
59        ontology: Option<&impl IsA<gio::File>>,
60        cancellable: Option<&impl IsA<gio::Cancellable>>,
61    ) -> Result<SparqlConnection, glib::Error> {
62        assert_initialized_main_thread!();
63        unsafe {
64            let mut error = std::ptr::null_mut();
65            let ret = ffi::tracker_sparql_connection_new(
66                flags.into_glib(),
67                store.map(|p| p.as_ref()).to_glib_none().0,
68                ontology.map(|p| p.as_ref()).to_glib_none().0,
69                cancellable.map(|p| p.as_ref()).to_glib_none().0,
70                &mut error,
71            );
72            if error.is_null() {
73                Ok(from_glib_full(ret))
74            } else {
75                Err(from_glib_full(error))
76            }
77        }
78    }
79
80    #[doc(alias = "tracker_sparql_connection_remote_new")]
81    pub fn remote_new(uri_base: &str) -> SparqlConnection {
82        assert_initialized_main_thread!();
83        unsafe {
84            from_glib_full(ffi::tracker_sparql_connection_remote_new(
85                uri_base.to_glib_none().0,
86            ))
87        }
88    }
89
90    #[doc(alias = "tracker_sparql_connection_close")]
91    pub fn close(&self) {
92        unsafe {
93            ffi::tracker_sparql_connection_close(self.to_glib_none().0);
94        }
95    }
96
97    #[doc(alias = "tracker_sparql_connection_close_async")]
98    pub fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
99        &self,
100        cancellable: Option<&impl IsA<gio::Cancellable>>,
101        callback: P,
102    ) {
103        let main_context = glib::MainContext::ref_thread_default();
104        let is_main_context_owner = main_context.is_owner();
105        let has_acquired_main_context = (!is_main_context_owner)
106            .then(|| main_context.acquire().ok())
107            .flatten();
108        assert!(
109            is_main_context_owner || has_acquired_main_context.is_some(),
110            "Async operations only allowed if the thread is owning the MainContext"
111        );
112
113        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
114            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
115        unsafe extern "C" fn close_async_trampoline<
116            P: FnOnce(Result<(), glib::Error>) + 'static,
117        >(
118            _source_object: *mut glib::gobject_ffi::GObject,
119            res: *mut gio::ffi::GAsyncResult,
120            user_data: glib::ffi::gpointer,
121        ) {
122            unsafe {
123                let mut error = std::ptr::null_mut();
124                ffi::tracker_sparql_connection_close_finish(
125                    _source_object as *mut _,
126                    res,
127                    &mut error,
128                );
129                let result = if error.is_null() {
130                    Ok(())
131                } else {
132                    Err(from_glib_full(error))
133                };
134                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
135                    Box_::from_raw(user_data as *mut _);
136                let callback: P = callback.into_inner();
137                callback(result);
138            }
139        }
140        let callback = close_async_trampoline::<P>;
141        unsafe {
142            ffi::tracker_sparql_connection_close_async(
143                self.to_glib_none().0,
144                cancellable.map(|p| p.as_ref()).to_glib_none().0,
145                Some(callback),
146                Box_::into_raw(user_data) as *mut _,
147            );
148        }
149    }
150
151    pub fn close_future(
152        &self,
153    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
154        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
155            obj.close_async(Some(cancellable), move |res| {
156                send.resolve(res);
157            });
158        }))
159    }
160
161    #[cfg(feature = "v3_1")]
162    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
163    #[doc(alias = "tracker_sparql_connection_create_batch")]
164    pub fn create_batch(&self) -> Option<Batch> {
165        unsafe {
166            from_glib_full(ffi::tracker_sparql_connection_create_batch(
167                self.to_glib_none().0,
168            ))
169        }
170    }
171
172    #[doc(alias = "tracker_sparql_connection_create_notifier")]
173    pub fn create_notifier(&self) -> Option<Notifier> {
174        unsafe {
175            from_glib_full(ffi::tracker_sparql_connection_create_notifier(
176                self.to_glib_none().0,
177            ))
178        }
179    }
180
181    #[cfg(feature = "v3_4")]
182    #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
183    #[doc(alias = "tracker_sparql_connection_deserialize_async")]
184    pub fn deserialize_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
185        &self,
186        flags: DeserializeFlags,
187        format: RdfFormat,
188        default_graph: &str,
189        stream: &impl IsA<gio::InputStream>,
190        cancellable: Option<&impl IsA<gio::Cancellable>>,
191        callback: P,
192    ) {
193        let main_context = glib::MainContext::ref_thread_default();
194        let is_main_context_owner = main_context.is_owner();
195        let has_acquired_main_context = (!is_main_context_owner)
196            .then(|| main_context.acquire().ok())
197            .flatten();
198        assert!(
199            is_main_context_owner || has_acquired_main_context.is_some(),
200            "Async operations only allowed if the thread is owning the MainContext"
201        );
202
203        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
204            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
205        unsafe extern "C" fn deserialize_async_trampoline<
206            P: FnOnce(Result<(), glib::Error>) + 'static,
207        >(
208            _source_object: *mut glib::gobject_ffi::GObject,
209            res: *mut gio::ffi::GAsyncResult,
210            user_data: glib::ffi::gpointer,
211        ) {
212            unsafe {
213                let mut error = std::ptr::null_mut();
214                ffi::tracker_sparql_connection_deserialize_finish(
215                    _source_object as *mut _,
216                    res,
217                    &mut error,
218                );
219                let result = if error.is_null() {
220                    Ok(())
221                } else {
222                    Err(from_glib_full(error))
223                };
224                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
225                    Box_::from_raw(user_data as *mut _);
226                let callback: P = callback.into_inner();
227                callback(result);
228            }
229        }
230        let callback = deserialize_async_trampoline::<P>;
231        unsafe {
232            ffi::tracker_sparql_connection_deserialize_async(
233                self.to_glib_none().0,
234                flags.into_glib(),
235                format.into_glib(),
236                default_graph.to_glib_none().0,
237                stream.as_ref().to_glib_none().0,
238                cancellable.map(|p| p.as_ref()).to_glib_none().0,
239                Some(callback),
240                Box_::into_raw(user_data) as *mut _,
241            );
242        }
243    }
244
245    #[cfg(feature = "v3_4")]
246    #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
247    pub fn deserialize_future(
248        &self,
249        flags: DeserializeFlags,
250        format: RdfFormat,
251        default_graph: &str,
252        stream: &(impl IsA<gio::InputStream> + Clone + 'static),
253    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
254        let default_graph = String::from(default_graph);
255        let stream = stream.clone();
256        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
257            obj.deserialize_async(
258                flags,
259                format,
260                &default_graph,
261                &stream,
262                Some(cancellable),
263                move |res| {
264                    send.resolve(res);
265                },
266            );
267        }))
268    }
269
270    #[doc(alias = "tracker_sparql_connection_get_namespace_manager")]
271    #[doc(alias = "get_namespace_manager")]
272    pub fn namespace_manager(&self) -> Option<NamespaceManager> {
273        unsafe {
274            from_glib_none(ffi::tracker_sparql_connection_get_namespace_manager(
275                self.to_glib_none().0,
276            ))
277        }
278    }
279
280    #[cfg(feature = "v3_3")]
281    #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
282    #[doc(alias = "tracker_sparql_connection_load_statement_from_gresource")]
283    pub fn load_statement_from_gresource(
284        &self,
285        resource_path: &str,
286        cancellable: Option<&impl IsA<gio::Cancellable>>,
287    ) -> Result<SparqlStatement, glib::Error> {
288        unsafe {
289            let mut error = std::ptr::null_mut();
290            let ret = ffi::tracker_sparql_connection_load_statement_from_gresource(
291                self.to_glib_none().0,
292                resource_path.to_glib_none().0,
293                cancellable.map(|p| p.as_ref()).to_glib_none().0,
294                &mut error,
295            );
296            if error.is_null() {
297                Ok(from_glib_full(ret))
298            } else {
299                Err(from_glib_full(error))
300            }
301        }
302    }
303
304    #[cfg(feature = "v3_3")]
305    #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
306    #[doc(alias = "tracker_sparql_connection_map_connection")]
307    pub fn map_connection(&self, handle_name: &str, service_connection: &SparqlConnection) {
308        unsafe {
309            ffi::tracker_sparql_connection_map_connection(
310                self.to_glib_none().0,
311                handle_name.to_glib_none().0,
312                service_connection.to_glib_none().0,
313            );
314        }
315    }
316
317    #[doc(alias = "tracker_sparql_connection_query")]
318    pub fn query(
319        &self,
320        sparql: &str,
321        cancellable: Option<&impl IsA<gio::Cancellable>>,
322    ) -> Result<SparqlCursor, glib::Error> {
323        unsafe {
324            let mut error = std::ptr::null_mut();
325            let ret = ffi::tracker_sparql_connection_query(
326                self.to_glib_none().0,
327                sparql.to_glib_none().0,
328                cancellable.map(|p| p.as_ref()).to_glib_none().0,
329                &mut error,
330            );
331            if error.is_null() {
332                Ok(from_glib_full(ret))
333            } else {
334                Err(from_glib_full(error))
335            }
336        }
337    }
338
339    #[doc(alias = "tracker_sparql_connection_query_async")]
340    pub fn query_async<P: FnOnce(Result<SparqlCursor, glib::Error>) + 'static>(
341        &self,
342        sparql: &str,
343        cancellable: Option<&impl IsA<gio::Cancellable>>,
344        callback: P,
345    ) {
346        let main_context = glib::MainContext::ref_thread_default();
347        let is_main_context_owner = main_context.is_owner();
348        let has_acquired_main_context = (!is_main_context_owner)
349            .then(|| main_context.acquire().ok())
350            .flatten();
351        assert!(
352            is_main_context_owner || has_acquired_main_context.is_some(),
353            "Async operations only allowed if the thread is owning the MainContext"
354        );
355
356        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
357            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
358        unsafe extern "C" fn query_async_trampoline<
359            P: FnOnce(Result<SparqlCursor, glib::Error>) + 'static,
360        >(
361            _source_object: *mut glib::gobject_ffi::GObject,
362            res: *mut gio::ffi::GAsyncResult,
363            user_data: glib::ffi::gpointer,
364        ) {
365            unsafe {
366                let mut error = std::ptr::null_mut();
367                let ret = ffi::tracker_sparql_connection_query_finish(
368                    _source_object as *mut _,
369                    res,
370                    &mut error,
371                );
372                let result = if error.is_null() {
373                    Ok(from_glib_full(ret))
374                } else {
375                    Err(from_glib_full(error))
376                };
377                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
378                    Box_::from_raw(user_data as *mut _);
379                let callback: P = callback.into_inner();
380                callback(result);
381            }
382        }
383        let callback = query_async_trampoline::<P>;
384        unsafe {
385            ffi::tracker_sparql_connection_query_async(
386                self.to_glib_none().0,
387                sparql.to_glib_none().0,
388                cancellable.map(|p| p.as_ref()).to_glib_none().0,
389                Some(callback),
390                Box_::into_raw(user_data) as *mut _,
391            );
392        }
393    }
394
395    pub fn query_future(
396        &self,
397        sparql: &str,
398    ) -> Pin<Box_<dyn std::future::Future<Output = Result<SparqlCursor, glib::Error>> + 'static>>
399    {
400        let sparql = String::from(sparql);
401        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
402            obj.query_async(&sparql, Some(cancellable), move |res| {
403                send.resolve(res);
404            });
405        }))
406    }
407
408    #[doc(alias = "tracker_sparql_connection_query_statement")]
409    pub fn query_statement(
410        &self,
411        sparql: &str,
412        cancellable: Option<&impl IsA<gio::Cancellable>>,
413    ) -> Result<SparqlStatement, glib::Error> {
414        unsafe {
415            let mut error = std::ptr::null_mut();
416            let ret = ffi::tracker_sparql_connection_query_statement(
417                self.to_glib_none().0,
418                sparql.to_glib_none().0,
419                cancellable.map(|p| p.as_ref()).to_glib_none().0,
420                &mut error,
421            );
422            if error.is_null() {
423                Ok(from_glib_full(ret))
424            } else {
425                Err(from_glib_full(error))
426            }
427        }
428    }
429
430    #[cfg(feature = "v3_3")]
431    #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
432    #[doc(alias = "tracker_sparql_connection_serialize_async")]
433    pub fn serialize_async<P: FnOnce(Result<gio::InputStream, glib::Error>) + 'static>(
434        &self,
435        flags: SerializeFlags,
436        format: RdfFormat,
437        query: &str,
438        cancellable: Option<&impl IsA<gio::Cancellable>>,
439        callback: P,
440    ) {
441        let main_context = glib::MainContext::ref_thread_default();
442        let is_main_context_owner = main_context.is_owner();
443        let has_acquired_main_context = (!is_main_context_owner)
444            .then(|| main_context.acquire().ok())
445            .flatten();
446        assert!(
447            is_main_context_owner || has_acquired_main_context.is_some(),
448            "Async operations only allowed if the thread is owning the MainContext"
449        );
450
451        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
452            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
453        unsafe extern "C" fn serialize_async_trampoline<
454            P: FnOnce(Result<gio::InputStream, glib::Error>) + 'static,
455        >(
456            _source_object: *mut glib::gobject_ffi::GObject,
457            res: *mut gio::ffi::GAsyncResult,
458            user_data: glib::ffi::gpointer,
459        ) {
460            unsafe {
461                let mut error = std::ptr::null_mut();
462                let ret = ffi::tracker_sparql_connection_serialize_finish(
463                    _source_object as *mut _,
464                    res,
465                    &mut error,
466                );
467                let result = if error.is_null() {
468                    Ok(from_glib_full(ret))
469                } else {
470                    Err(from_glib_full(error))
471                };
472                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
473                    Box_::from_raw(user_data as *mut _);
474                let callback: P = callback.into_inner();
475                callback(result);
476            }
477        }
478        let callback = serialize_async_trampoline::<P>;
479        unsafe {
480            ffi::tracker_sparql_connection_serialize_async(
481                self.to_glib_none().0,
482                flags.into_glib(),
483                format.into_glib(),
484                query.to_glib_none().0,
485                cancellable.map(|p| p.as_ref()).to_glib_none().0,
486                Some(callback),
487                Box_::into_raw(user_data) as *mut _,
488            );
489        }
490    }
491
492    #[cfg(feature = "v3_3")]
493    #[cfg_attr(docsrs, doc(cfg(feature = "v3_3")))]
494    pub fn serialize_future(
495        &self,
496        flags: SerializeFlags,
497        format: RdfFormat,
498        query: &str,
499    ) -> Pin<Box_<dyn std::future::Future<Output = Result<gio::InputStream, glib::Error>> + 'static>>
500    {
501        let query = String::from(query);
502        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
503            obj.serialize_async(flags, format, &query, Some(cancellable), move |res| {
504                send.resolve(res);
505            });
506        }))
507    }
508
509    #[doc(alias = "tracker_sparql_connection_update_async")]
510    pub fn update_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
511        &self,
512        sparql: &str,
513        cancellable: Option<&impl IsA<gio::Cancellable>>,
514        callback: P,
515    ) {
516        let main_context = glib::MainContext::ref_thread_default();
517        let is_main_context_owner = main_context.is_owner();
518        let has_acquired_main_context = (!is_main_context_owner)
519            .then(|| main_context.acquire().ok())
520            .flatten();
521        assert!(
522            is_main_context_owner || has_acquired_main_context.is_some(),
523            "Async operations only allowed if the thread is owning the MainContext"
524        );
525
526        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
527            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
528        unsafe extern "C" fn update_async_trampoline<
529            P: FnOnce(Result<(), glib::Error>) + 'static,
530        >(
531            _source_object: *mut glib::gobject_ffi::GObject,
532            res: *mut gio::ffi::GAsyncResult,
533            user_data: glib::ffi::gpointer,
534        ) {
535            unsafe {
536                let mut error = std::ptr::null_mut();
537                ffi::tracker_sparql_connection_update_finish(
538                    _source_object as *mut _,
539                    res,
540                    &mut error,
541                );
542                let result = if error.is_null() {
543                    Ok(())
544                } else {
545                    Err(from_glib_full(error))
546                };
547                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
548                    Box_::from_raw(user_data as *mut _);
549                let callback: P = callback.into_inner();
550                callback(result);
551            }
552        }
553        let callback = update_async_trampoline::<P>;
554        unsafe {
555            ffi::tracker_sparql_connection_update_async(
556                self.to_glib_none().0,
557                sparql.to_glib_none().0,
558                cancellable.map(|p| p.as_ref()).to_glib_none().0,
559                Some(callback),
560                Box_::into_raw(user_data) as *mut _,
561            );
562        }
563    }
564
565    pub fn update_future(
566        &self,
567        sparql: &str,
568    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
569        let sparql = String::from(sparql);
570        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
571            obj.update_async(&sparql, Some(cancellable), move |res| {
572                send.resolve(res);
573            });
574        }))
575    }
576
577    #[cfg_attr(feature = "v3_5", deprecated = "Since 3.5")]
578    #[allow(deprecated)]
579    #[doc(alias = "tracker_sparql_connection_update_blank")]
580    pub fn update_blank(
581        &self,
582        sparql: &str,
583        cancellable: Option<&impl IsA<gio::Cancellable>>,
584    ) -> Result<glib::Variant, glib::Error> {
585        unsafe {
586            let mut error = std::ptr::null_mut();
587            let ret = ffi::tracker_sparql_connection_update_blank(
588                self.to_glib_none().0,
589                sparql.to_glib_none().0,
590                cancellable.map(|p| p.as_ref()).to_glib_none().0,
591                &mut error,
592            );
593            if error.is_null() {
594                Ok(from_glib_full(ret))
595            } else {
596                Err(from_glib_full(error))
597            }
598        }
599    }
600
601    #[cfg_attr(feature = "v3_5", deprecated = "Since 3.5")]
602    #[allow(deprecated)]
603    #[doc(alias = "tracker_sparql_connection_update_blank_async")]
604    pub fn update_blank_async<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
605        &self,
606        sparql: &str,
607        cancellable: Option<&impl IsA<gio::Cancellable>>,
608        callback: P,
609    ) {
610        let main_context = glib::MainContext::ref_thread_default();
611        let is_main_context_owner = main_context.is_owner();
612        let has_acquired_main_context = (!is_main_context_owner)
613            .then(|| main_context.acquire().ok())
614            .flatten();
615        assert!(
616            is_main_context_owner || has_acquired_main_context.is_some(),
617            "Async operations only allowed if the thread is owning the MainContext"
618        );
619
620        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
621            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
622        unsafe extern "C" fn update_blank_async_trampoline<
623            P: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
624        >(
625            _source_object: *mut glib::gobject_ffi::GObject,
626            res: *mut gio::ffi::GAsyncResult,
627            user_data: glib::ffi::gpointer,
628        ) {
629            unsafe {
630                let mut error = std::ptr::null_mut();
631                let ret = ffi::tracker_sparql_connection_update_blank_finish(
632                    _source_object as *mut _,
633                    res,
634                    &mut error,
635                );
636                let result = if error.is_null() {
637                    Ok(from_glib_full(ret))
638                } else {
639                    Err(from_glib_full(error))
640                };
641                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
642                    Box_::from_raw(user_data as *mut _);
643                let callback: P = callback.into_inner();
644                callback(result);
645            }
646        }
647        let callback = update_blank_async_trampoline::<P>;
648        unsafe {
649            ffi::tracker_sparql_connection_update_blank_async(
650                self.to_glib_none().0,
651                sparql.to_glib_none().0,
652                cancellable.map(|p| p.as_ref()).to_glib_none().0,
653                Some(callback),
654                Box_::into_raw(user_data) as *mut _,
655            );
656        }
657    }
658
659    #[cfg_attr(feature = "v3_5", deprecated = "Since 3.5")]
660
661    pub fn update_blank_future(
662        &self,
663        sparql: &str,
664    ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>
665    {
666        let sparql = String::from(sparql);
667        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
668            obj.update_blank_async(&sparql, Some(cancellable), move |res| {
669                send.resolve(res);
670            });
671        }))
672    }
673
674    #[cfg(feature = "v3_1")]
675    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
676    #[doc(alias = "tracker_sparql_connection_update_resource")]
677    pub fn update_resource(
678        &self,
679        graph: Option<&str>,
680        resource: &Resource,
681        cancellable: Option<&impl IsA<gio::Cancellable>>,
682    ) -> Result<(), glib::Error> {
683        unsafe {
684            let mut error = std::ptr::null_mut();
685            let is_ok = ffi::tracker_sparql_connection_update_resource(
686                self.to_glib_none().0,
687                graph.to_glib_none().0,
688                resource.to_glib_none().0,
689                cancellable.map(|p| p.as_ref()).to_glib_none().0,
690                &mut error,
691            );
692            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
693            if error.is_null() {
694                Ok(())
695            } else {
696                Err(from_glib_full(error))
697            }
698        }
699    }
700
701    #[cfg(feature = "v3_1")]
702    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
703    #[doc(alias = "tracker_sparql_connection_update_resource_async")]
704    pub fn update_resource_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
705        &self,
706        graph: Option<&str>,
707        resource: &Resource,
708        cancellable: Option<&impl IsA<gio::Cancellable>>,
709        callback: P,
710    ) {
711        let main_context = glib::MainContext::ref_thread_default();
712        let is_main_context_owner = main_context.is_owner();
713        let has_acquired_main_context = (!is_main_context_owner)
714            .then(|| main_context.acquire().ok())
715            .flatten();
716        assert!(
717            is_main_context_owner || has_acquired_main_context.is_some(),
718            "Async operations only allowed if the thread is owning the MainContext"
719        );
720
721        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
722            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
723        unsafe extern "C" fn update_resource_async_trampoline<
724            P: FnOnce(Result<(), glib::Error>) + 'static,
725        >(
726            _source_object: *mut glib::gobject_ffi::GObject,
727            res: *mut gio::ffi::GAsyncResult,
728            user_data: glib::ffi::gpointer,
729        ) {
730            unsafe {
731                let mut error = std::ptr::null_mut();
732                ffi::tracker_sparql_connection_update_resource_finish(
733                    _source_object as *mut _,
734                    res,
735                    &mut error,
736                );
737                let result = if error.is_null() {
738                    Ok(())
739                } else {
740                    Err(from_glib_full(error))
741                };
742                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
743                    Box_::from_raw(user_data as *mut _);
744                let callback: P = callback.into_inner();
745                callback(result);
746            }
747        }
748        let callback = update_resource_async_trampoline::<P>;
749        unsafe {
750            ffi::tracker_sparql_connection_update_resource_async(
751                self.to_glib_none().0,
752                graph.to_glib_none().0,
753                resource.to_glib_none().0,
754                cancellable.map(|p| p.as_ref()).to_glib_none().0,
755                Some(callback),
756                Box_::into_raw(user_data) as *mut _,
757            );
758        }
759    }
760
761    #[cfg(feature = "v3_1")]
762    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
763    pub fn update_resource_future(
764        &self,
765        graph: Option<&str>,
766        resource: &Resource,
767    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
768        let graph = graph.map(ToOwned::to_owned);
769        let resource = resource.clone();
770        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
771            obj.update_resource_async(
772                graph.as_ref().map(::std::borrow::Borrow::borrow),
773                &resource,
774                Some(cancellable),
775                move |res| {
776                    send.resolve(res);
777                },
778            );
779        }))
780    }
781
782    #[cfg(feature = "v3_5")]
783    #[cfg_attr(docsrs, doc(cfg(feature = "v3_5")))]
784    #[doc(alias = "tracker_sparql_connection_update_statement")]
785    pub fn update_statement(
786        &self,
787        sparql: &str,
788        cancellable: Option<&impl IsA<gio::Cancellable>>,
789    ) -> Result<SparqlStatement, glib::Error> {
790        unsafe {
791            let mut error = std::ptr::null_mut();
792            let ret = ffi::tracker_sparql_connection_update_statement(
793                self.to_glib_none().0,
794                sparql.to_glib_none().0,
795                cancellable.map(|p| p.as_ref()).to_glib_none().0,
796                &mut error,
797            );
798            if error.is_null() {
799                Ok(from_glib_full(ret))
800            } else {
801                Err(from_glib_full(error))
802            }
803        }
804    }
805
806    #[cfg(feature = "v3_1")]
807    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
808    #[doc(alias = "tracker_sparql_connection_bus_new_async")]
809    pub fn bus_new_async<P: FnOnce(Result<SparqlConnection, glib::Error>) + 'static>(
810        service_name: &str,
811        object_path: Option<&str>,
812        dbus_connection: Option<&gio::DBusConnection>,
813        cancellable: Option<&impl IsA<gio::Cancellable>>,
814        callback: P,
815    ) {
816        assert_initialized_main_thread!();
817
818        let main_context = glib::MainContext::ref_thread_default();
819        let is_main_context_owner = main_context.is_owner();
820        let has_acquired_main_context = (!is_main_context_owner)
821            .then(|| main_context.acquire().ok())
822            .flatten();
823        assert!(
824            is_main_context_owner || has_acquired_main_context.is_some(),
825            "Async operations only allowed if the thread is owning the MainContext"
826        );
827
828        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
829            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
830        unsafe extern "C" fn bus_new_async_trampoline<
831            P: FnOnce(Result<SparqlConnection, glib::Error>) + 'static,
832        >(
833            _source_object: *mut glib::gobject_ffi::GObject,
834            res: *mut gio::ffi::GAsyncResult,
835            user_data: glib::ffi::gpointer,
836        ) {
837            unsafe {
838                let mut error = std::ptr::null_mut();
839                let ret = ffi::tracker_sparql_connection_bus_new_finish(res, &mut error);
840                let result = if error.is_null() {
841                    Ok(from_glib_full(ret))
842                } else {
843                    Err(from_glib_full(error))
844                };
845                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
846                    Box_::from_raw(user_data as *mut _);
847                let callback: P = callback.into_inner();
848                callback(result);
849            }
850        }
851        let callback = bus_new_async_trampoline::<P>;
852        unsafe {
853            ffi::tracker_sparql_connection_bus_new_async(
854                service_name.to_glib_none().0,
855                object_path.to_glib_none().0,
856                dbus_connection.to_glib_none().0,
857                cancellable.map(|p| p.as_ref()).to_glib_none().0,
858                Some(callback),
859                Box_::into_raw(user_data) as *mut _,
860            );
861        }
862    }
863
864    #[cfg(feature = "v3_1")]
865    #[cfg_attr(docsrs, doc(cfg(feature = "v3_1")))]
866    pub fn bus_new_future(
867        service_name: &str,
868        object_path: Option<&str>,
869        dbus_connection: Option<&gio::DBusConnection>,
870    ) -> Pin<Box_<dyn std::future::Future<Output = Result<SparqlConnection, glib::Error>> + 'static>>
871    {
872        skip_assert_initialized!();
873        let service_name = String::from(service_name);
874        let object_path = object_path.map(ToOwned::to_owned);
875        let dbus_connection = dbus_connection.map(ToOwned::to_owned);
876        Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| {
877            Self::bus_new_async(
878                &service_name,
879                object_path.as_ref().map(::std::borrow::Borrow::borrow),
880                dbus_connection.as_ref().map(::std::borrow::Borrow::borrow),
881                Some(cancellable),
882                move |res| {
883                    send.resolve(res);
884                },
885            );
886        }))
887    }
888
889    #[doc(alias = "tracker_sparql_connection_new_async")]
890    pub fn new_async<P: FnOnce(Result<SparqlConnection, glib::Error>) + 'static>(
891        flags: SparqlConnectionFlags,
892        store: Option<&impl IsA<gio::File>>,
893        ontology: Option<&impl IsA<gio::File>>,
894        cancellable: Option<&impl IsA<gio::Cancellable>>,
895        callback: P,
896    ) {
897        assert_initialized_main_thread!();
898
899        let main_context = glib::MainContext::ref_thread_default();
900        let is_main_context_owner = main_context.is_owner();
901        let has_acquired_main_context = (!is_main_context_owner)
902            .then(|| main_context.acquire().ok())
903            .flatten();
904        assert!(
905            is_main_context_owner || has_acquired_main_context.is_some(),
906            "Async operations only allowed if the thread is owning the MainContext"
907        );
908
909        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
910            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
911        unsafe extern "C" fn new_async_trampoline<
912            P: FnOnce(Result<SparqlConnection, glib::Error>) + 'static,
913        >(
914            _source_object: *mut glib::gobject_ffi::GObject,
915            res: *mut gio::ffi::GAsyncResult,
916            user_data: glib::ffi::gpointer,
917        ) {
918            unsafe {
919                let mut error = std::ptr::null_mut();
920                let ret = ffi::tracker_sparql_connection_new_finish(res, &mut error);
921                let result = if error.is_null() {
922                    Ok(from_glib_full(ret))
923                } else {
924                    Err(from_glib_full(error))
925                };
926                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
927                    Box_::from_raw(user_data as *mut _);
928                let callback: P = callback.into_inner();
929                callback(result);
930            }
931        }
932        let callback = new_async_trampoline::<P>;
933        unsafe {
934            ffi::tracker_sparql_connection_new_async(
935                flags.into_glib(),
936                store.map(|p| p.as_ref()).to_glib_none().0,
937                ontology.map(|p| p.as_ref()).to_glib_none().0,
938                cancellable.map(|p| p.as_ref()).to_glib_none().0,
939                Some(callback),
940                Box_::into_raw(user_data) as *mut _,
941            );
942        }
943    }
944
945    pub fn new_future(
946        flags: SparqlConnectionFlags,
947        store: Option<&(impl IsA<gio::File> + Clone + 'static)>,
948        ontology: Option<&(impl IsA<gio::File> + Clone + 'static)>,
949    ) -> Pin<Box_<dyn std::future::Future<Output = Result<SparqlConnection, glib::Error>> + 'static>>
950    {
951        skip_assert_initialized!();
952        let store = store.map(ToOwned::to_owned);
953        let ontology = ontology.map(ToOwned::to_owned);
954        Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| {
955            Self::new_async(
956                flags,
957                store.as_ref().map(::std::borrow::Borrow::borrow),
958                ontology.as_ref().map(::std::borrow::Borrow::borrow),
959                Some(cancellable),
960                move |res| {
961                    send.resolve(res);
962                },
963            );
964        }))
965    }
966}
tracker/auto/sparql_connection.rs

tracker/auto/
sparql_connection.rs
