1#[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}