gio/auto/
input_stream.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5#[cfg(feature = "futures")]
6use futures::future;
7use gio_sys;
8use glib;
9use glib::object::IsA;
10use glib::translate::*;
11use glib_sys;
12use gobject_sys;
13#[cfg(feature = "futures")]
14use std::boxed::Box as Box_;
15use std::fmt;
16use std::ptr;
17use Cancellable;
18use Error;
19
20glib_wrapper! {
21    pub struct InputStream(Object<gio_sys::GInputStream, gio_sys::GInputStreamClass, InputStreamClass>);
22
23    match fn {
24        get_type => || gio_sys::g_input_stream_get_type(),
25    }
26}
27
28pub const NONE_INPUT_STREAM: Option<&InputStream> = None;
29
30pub trait InputStreamExt: 'static {
31    fn clear_pending(&self);
32
33    fn close<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<(), Error>;
34
35    fn close_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
36        &self,
37        io_priority: glib::Priority,
38        cancellable: Option<&P>,
39        callback: Q,
40    );
41
42    #[cfg(feature = "futures")]
43    fn close_async_future(
44        &self,
45        io_priority: glib::Priority,
46    ) -> Box_<dyn future::Future<Output = Result<(), Error>> + std::marker::Unpin>;
47
48    fn has_pending(&self) -> bool;
49
50    fn is_closed(&self) -> bool;
51
52    fn read_bytes<P: IsA<Cancellable>>(
53        &self,
54        count: usize,
55        cancellable: Option<&P>,
56    ) -> Result<glib::Bytes, Error>;
57
58    fn read_bytes_async<
59        P: IsA<Cancellable>,
60        Q: FnOnce(Result<glib::Bytes, Error>) + Send + 'static,
61    >(
62        &self,
63        count: usize,
64        io_priority: glib::Priority,
65        cancellable: Option<&P>,
66        callback: Q,
67    );
68
69    #[cfg(feature = "futures")]
70    fn read_bytes_async_future(
71        &self,
72        count: usize,
73        io_priority: glib::Priority,
74    ) -> Box_<dyn future::Future<Output = Result<glib::Bytes, Error>> + std::marker::Unpin>;
75
76    fn set_pending(&self) -> Result<(), Error>;
77
78    fn skip<P: IsA<Cancellable>>(
79        &self,
80        count: usize,
81        cancellable: Option<&P>,
82    ) -> Result<isize, Error>;
83
84    fn skip_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, Error>) + Send + 'static>(
85        &self,
86        count: usize,
87        io_priority: glib::Priority,
88        cancellable: Option<&P>,
89        callback: Q,
90    );
91
92    #[cfg(feature = "futures")]
93    fn skip_async_future(
94        &self,
95        count: usize,
96        io_priority: glib::Priority,
97    ) -> Box_<dyn future::Future<Output = Result<isize, Error>> + std::marker::Unpin>;
98}
99
100impl<O: IsA<InputStream>> InputStreamExt for O {
101    fn clear_pending(&self) {
102        unsafe {
103            gio_sys::g_input_stream_clear_pending(self.as_ref().to_glib_none().0);
104        }
105    }
106
107    fn close<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<(), Error> {
108        unsafe {
109            let mut error = ptr::null_mut();
110            let _ = gio_sys::g_input_stream_close(
111                self.as_ref().to_glib_none().0,
112                cancellable.map(|p| p.as_ref()).to_glib_none().0,
113                &mut error,
114            );
115            if error.is_null() {
116                Ok(())
117            } else {
118                Err(from_glib_full(error))
119            }
120        }
121    }
122
123    fn close_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
124        &self,
125        io_priority: glib::Priority,
126        cancellable: Option<&P>,
127        callback: Q,
128    ) {
129        let user_data: Box<Q> = Box::new(callback);
130        unsafe extern "C" fn close_async_trampoline<
131            Q: FnOnce(Result<(), Error>) + Send + 'static,
132        >(
133            _source_object: *mut gobject_sys::GObject,
134            res: *mut gio_sys::GAsyncResult,
135            user_data: glib_sys::gpointer,
136        ) {
137            let mut error = ptr::null_mut();
138            let _ = gio_sys::g_input_stream_close_finish(_source_object as *mut _, res, &mut error);
139            let result = if error.is_null() {
140                Ok(())
141            } else {
142                Err(from_glib_full(error))
143            };
144            let callback: Box<Q> = Box::from_raw(user_data as *mut _);
145            callback(result);
146        }
147        let callback = close_async_trampoline::<Q>;
148        unsafe {
149            gio_sys::g_input_stream_close_async(
150                self.as_ref().to_glib_none().0,
151                io_priority.to_glib(),
152                cancellable.map(|p| p.as_ref()).to_glib_none().0,
153                Some(callback),
154                Box::into_raw(user_data) as *mut _,
155            );
156        }
157    }
158
159    #[cfg(feature = "futures")]
160    fn close_async_future(
161        &self,
162        io_priority: glib::Priority,
163    ) -> Box_<dyn future::Future<Output = Result<(), Error>> + std::marker::Unpin> {
164        use fragile::Fragile;
165        use GioFuture;
166
167        GioFuture::new(self, move |obj, send| {
168            let cancellable = Cancellable::new();
169            let send = Fragile::new(send);
170            obj.close_async(io_priority, Some(&cancellable), move |res| {
171                let _ = send.into_inner().send(res);
172            });
173
174            cancellable
175        })
176    }
177
178    fn has_pending(&self) -> bool {
179        unsafe {
180            from_glib(gio_sys::g_input_stream_has_pending(
181                self.as_ref().to_glib_none().0,
182            ))
183        }
184    }
185
186    fn is_closed(&self) -> bool {
187        unsafe {
188            from_glib(gio_sys::g_input_stream_is_closed(
189                self.as_ref().to_glib_none().0,
190            ))
191        }
192    }
193
194    fn read_bytes<P: IsA<Cancellable>>(
195        &self,
196        count: usize,
197        cancellable: Option<&P>,
198    ) -> Result<glib::Bytes, Error> {
199        unsafe {
200            let mut error = ptr::null_mut();
201            let ret = gio_sys::g_input_stream_read_bytes(
202                self.as_ref().to_glib_none().0,
203                count,
204                cancellable.map(|p| p.as_ref()).to_glib_none().0,
205                &mut error,
206            );
207            if error.is_null() {
208                Ok(from_glib_full(ret))
209            } else {
210                Err(from_glib_full(error))
211            }
212        }
213    }
214
215    fn read_bytes_async<
216        P: IsA<Cancellable>,
217        Q: FnOnce(Result<glib::Bytes, Error>) + Send + 'static,
218    >(
219        &self,
220        count: usize,
221        io_priority: glib::Priority,
222        cancellable: Option<&P>,
223        callback: Q,
224    ) {
225        let user_data: Box<Q> = Box::new(callback);
226        unsafe extern "C" fn read_bytes_async_trampoline<
227            Q: FnOnce(Result<glib::Bytes, Error>) + Send + 'static,
228        >(
229            _source_object: *mut gobject_sys::GObject,
230            res: *mut gio_sys::GAsyncResult,
231            user_data: glib_sys::gpointer,
232        ) {
233            let mut error = ptr::null_mut();
234            let ret = gio_sys::g_input_stream_read_bytes_finish(
235                _source_object as *mut _,
236                res,
237                &mut error,
238            );
239            let result = if error.is_null() {
240                Ok(from_glib_full(ret))
241            } else {
242                Err(from_glib_full(error))
243            };
244            let callback: Box<Q> = Box::from_raw(user_data as *mut _);
245            callback(result);
246        }
247        let callback = read_bytes_async_trampoline::<Q>;
248        unsafe {
249            gio_sys::g_input_stream_read_bytes_async(
250                self.as_ref().to_glib_none().0,
251                count,
252                io_priority.to_glib(),
253                cancellable.map(|p| p.as_ref()).to_glib_none().0,
254                Some(callback),
255                Box::into_raw(user_data) as *mut _,
256            );
257        }
258    }
259
260    #[cfg(feature = "futures")]
261    fn read_bytes_async_future(
262        &self,
263        count: usize,
264        io_priority: glib::Priority,
265    ) -> Box_<dyn future::Future<Output = Result<glib::Bytes, Error>> + std::marker::Unpin> {
266        use fragile::Fragile;
267        use GioFuture;
268
269        GioFuture::new(self, move |obj, send| {
270            let cancellable = Cancellable::new();
271            let send = Fragile::new(send);
272            obj.read_bytes_async(count, io_priority, Some(&cancellable), move |res| {
273                let _ = send.into_inner().send(res);
274            });
275
276            cancellable
277        })
278    }
279
280    fn set_pending(&self) -> Result<(), Error> {
281        unsafe {
282            let mut error = ptr::null_mut();
283            let _ = gio_sys::g_input_stream_set_pending(self.as_ref().to_glib_none().0, &mut error);
284            if error.is_null() {
285                Ok(())
286            } else {
287                Err(from_glib_full(error))
288            }
289        }
290    }
291
292    fn skip<P: IsA<Cancellable>>(
293        &self,
294        count: usize,
295        cancellable: Option<&P>,
296    ) -> Result<isize, Error> {
297        unsafe {
298            let mut error = ptr::null_mut();
299            let ret = gio_sys::g_input_stream_skip(
300                self.as_ref().to_glib_none().0,
301                count,
302                cancellable.map(|p| p.as_ref()).to_glib_none().0,
303                &mut error,
304            );
305            if error.is_null() {
306                Ok(ret)
307            } else {
308                Err(from_glib_full(error))
309            }
310        }
311    }
312
313    fn skip_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, Error>) + Send + 'static>(
314        &self,
315        count: usize,
316        io_priority: glib::Priority,
317        cancellable: Option<&P>,
318        callback: Q,
319    ) {
320        let user_data: Box<Q> = Box::new(callback);
321        unsafe extern "C" fn skip_async_trampoline<
322            Q: FnOnce(Result<isize, Error>) + Send + 'static,
323        >(
324            _source_object: *mut gobject_sys::GObject,
325            res: *mut gio_sys::GAsyncResult,
326            user_data: glib_sys::gpointer,
327        ) {
328            let mut error = ptr::null_mut();
329            let ret =
330                gio_sys::g_input_stream_skip_finish(_source_object as *mut _, res, &mut error);
331            let result = if error.is_null() {
332                Ok(ret)
333            } else {
334                Err(from_glib_full(error))
335            };
336            let callback: Box<Q> = Box::from_raw(user_data as *mut _);
337            callback(result);
338        }
339        let callback = skip_async_trampoline::<Q>;
340        unsafe {
341            gio_sys::g_input_stream_skip_async(
342                self.as_ref().to_glib_none().0,
343                count,
344                io_priority.to_glib(),
345                cancellable.map(|p| p.as_ref()).to_glib_none().0,
346                Some(callback),
347                Box::into_raw(user_data) as *mut _,
348            );
349        }
350    }
351
352    #[cfg(feature = "futures")]
353    fn skip_async_future(
354        &self,
355        count: usize,
356        io_priority: glib::Priority,
357    ) -> Box_<dyn future::Future<Output = Result<isize, Error>> + std::marker::Unpin> {
358        use fragile::Fragile;
359        use GioFuture;
360
361        GioFuture::new(self, move |obj, send| {
362            let cancellable = Cancellable::new();
363            let send = Fragile::new(send);
364            obj.skip_async(count, io_priority, Some(&cancellable), move |res| {
365                let _ = send.into_inner().send(res);
366            });
367
368            cancellable
369        })
370    }
371}
372
373impl fmt::Display for InputStream {
374    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
375        write!(f, "InputStream")
376    }
377}