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 use gio_sys; 6 use glib; 7 use glib::object::Cast; 8 use glib::object::IsA; 9 use glib::signal::connect_raw; 10 use glib::signal::SignalHandlerId; 11 use glib::translate::*; 12 use glib::StaticType; 13 use glib::ToValue; 14 use glib_sys; 15 use gobject_sys; 16 use std::boxed::Box as Box_; 17 use std::fmt; 18 use std::mem; 19 use std::mem::transmute; 20 use std::pin::Pin; 21 use std::ptr; 22 use Cancellable; 23 use FilterInputStream; 24 use InputStream; 25 use Seekable; 26 27 glib_wrapper! { 28 pub struct BufferedInputStream(Object<gio_sys::GBufferedInputStream, gio_sys::GBufferedInputStreamClass, BufferedInputStreamClass>) @extends FilterInputStream, InputStream, @implements Seekable; 29 30 match fn { 31 get_type => || gio_sys::g_buffered_input_stream_get_type(), 32 } 33 } 34 35 impl BufferedInputStream { new<P: IsA<InputStream>>(base_stream: &P) -> BufferedInputStream36 pub fn new<P: IsA<InputStream>>(base_stream: &P) -> BufferedInputStream { 37 unsafe { 38 InputStream::from_glib_full(gio_sys::g_buffered_input_stream_new( 39 base_stream.as_ref().to_glib_none().0, 40 )) 41 .unsafe_cast() 42 } 43 } 44 new_sized<P: IsA<InputStream>>(base_stream: &P, size: usize) -> BufferedInputStream45 pub fn new_sized<P: IsA<InputStream>>(base_stream: &P, size: usize) -> BufferedInputStream { 46 unsafe { 47 InputStream::from_glib_full(gio_sys::g_buffered_input_stream_new_sized( 48 base_stream.as_ref().to_glib_none().0, 49 size, 50 )) 51 .unsafe_cast() 52 } 53 } 54 } 55 56 #[derive(Clone, Default)] 57 pub struct BufferedInputStreamBuilder { 58 buffer_size: Option<u32>, 59 base_stream: Option<InputStream>, 60 close_base_stream: Option<bool>, 61 } 62 63 impl BufferedInputStreamBuilder { new() -> Self64 pub fn new() -> Self { 65 Self::default() 66 } 67 build(self) -> BufferedInputStream68 pub fn build(self) -> BufferedInputStream { 69 let mut properties: Vec<(&str, &dyn ToValue)> = vec![]; 70 if let Some(ref buffer_size) = self.buffer_size { 71 properties.push(("buffer-size", buffer_size)); 72 } 73 if let Some(ref base_stream) = self.base_stream { 74 properties.push(("base-stream", base_stream)); 75 } 76 if let Some(ref close_base_stream) = self.close_base_stream { 77 properties.push(("close-base-stream", close_base_stream)); 78 } 79 glib::Object::new(BufferedInputStream::static_type(), &properties) 80 .expect("object new") 81 .downcast() 82 .expect("downcast") 83 } 84 buffer_size(mut self, buffer_size: u32) -> Self85 pub fn buffer_size(mut self, buffer_size: u32) -> Self { 86 self.buffer_size = Some(buffer_size); 87 self 88 } 89 base_stream<P: IsA<InputStream>>(mut self, base_stream: &P) -> Self90 pub fn base_stream<P: IsA<InputStream>>(mut self, base_stream: &P) -> Self { 91 self.base_stream = Some(base_stream.clone().upcast()); 92 self 93 } 94 close_base_stream(mut self, close_base_stream: bool) -> Self95 pub fn close_base_stream(mut self, close_base_stream: bool) -> Self { 96 self.close_base_stream = Some(close_base_stream); 97 self 98 } 99 } 100 101 pub const NONE_BUFFERED_INPUT_STREAM: Option<&BufferedInputStream> = None; 102 103 pub trait BufferedInputStreamExt: 'static { fill<P: IsA<Cancellable>>( &self, count: isize, cancellable: Option<&P>, ) -> Result<isize, glib::Error>104 fn fill<P: IsA<Cancellable>>( 105 &self, 106 count: isize, 107 cancellable: Option<&P>, 108 ) -> Result<isize, glib::Error>; 109 fill_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + Send + 'static>( &self, count: isize, io_priority: glib::Priority, cancellable: Option<&P>, callback: Q, )110 fn fill_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + Send + 'static>( 111 &self, 112 count: isize, 113 io_priority: glib::Priority, 114 cancellable: Option<&P>, 115 callback: Q, 116 ); 117 fill_async_future( &self, count: isize, io_priority: glib::Priority, ) -> Pin<Box_<dyn std::future::Future<Output = Result<isize, glib::Error>> + 'static>>118 fn fill_async_future( 119 &self, 120 count: isize, 121 io_priority: glib::Priority, 122 ) -> Pin<Box_<dyn std::future::Future<Output = Result<isize, glib::Error>> + 'static>>; 123 get_available(&self) -> usize124 fn get_available(&self) -> usize; 125 get_buffer_size(&self) -> usize126 fn get_buffer_size(&self) -> usize; 127 peek_buffer(&self) -> Vec<u8>128 fn peek_buffer(&self) -> Vec<u8>; 129 read_byte<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<i32, glib::Error>130 fn read_byte<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<i32, glib::Error>; 131 set_buffer_size(&self, size: usize)132 fn set_buffer_size(&self, size: usize); 133 connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId134 fn connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; 135 } 136 137 impl<O: IsA<BufferedInputStream>> BufferedInputStreamExt for O { fill<P: IsA<Cancellable>>( &self, count: isize, cancellable: Option<&P>, ) -> Result<isize, glib::Error>138 fn fill<P: IsA<Cancellable>>( 139 &self, 140 count: isize, 141 cancellable: Option<&P>, 142 ) -> Result<isize, glib::Error> { 143 unsafe { 144 let mut error = ptr::null_mut(); 145 let ret = gio_sys::g_buffered_input_stream_fill( 146 self.as_ref().to_glib_none().0, 147 count, 148 cancellable.map(|p| p.as_ref()).to_glib_none().0, 149 &mut error, 150 ); 151 if error.is_null() { 152 Ok(ret) 153 } else { 154 Err(from_glib_full(error)) 155 } 156 } 157 } 158 fill_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + Send + 'static>( &self, count: isize, io_priority: glib::Priority, cancellable: Option<&P>, callback: Q, )159 fn fill_async<P: IsA<Cancellable>, Q: FnOnce(Result<isize, glib::Error>) + Send + 'static>( 160 &self, 161 count: isize, 162 io_priority: glib::Priority, 163 cancellable: Option<&P>, 164 callback: Q, 165 ) { 166 let user_data: Box_<Q> = Box_::new(callback); 167 unsafe extern "C" fn fill_async_trampoline< 168 Q: FnOnce(Result<isize, glib::Error>) + Send + 'static, 169 >( 170 _source_object: *mut gobject_sys::GObject, 171 res: *mut gio_sys::GAsyncResult, 172 user_data: glib_sys::gpointer, 173 ) { 174 let mut error = ptr::null_mut(); 175 let ret = gio_sys::g_buffered_input_stream_fill_finish( 176 _source_object as *mut _, 177 res, 178 &mut error, 179 ); 180 let result = if error.is_null() { 181 Ok(ret) 182 } else { 183 Err(from_glib_full(error)) 184 }; 185 let callback: Box_<Q> = Box_::from_raw(user_data as *mut _); 186 callback(result); 187 } 188 let callback = fill_async_trampoline::<Q>; 189 unsafe { 190 gio_sys::g_buffered_input_stream_fill_async( 191 self.as_ref().to_glib_none().0, 192 count, 193 io_priority.to_glib(), 194 cancellable.map(|p| p.as_ref()).to_glib_none().0, 195 Some(callback), 196 Box_::into_raw(user_data) as *mut _, 197 ); 198 } 199 } 200 fill_async_future( &self, count: isize, io_priority: glib::Priority, ) -> Pin<Box_<dyn std::future::Future<Output = Result<isize, glib::Error>> + 'static>>201 fn fill_async_future( 202 &self, 203 count: isize, 204 io_priority: glib::Priority, 205 ) -> Pin<Box_<dyn std::future::Future<Output = Result<isize, glib::Error>> + 'static>> { 206 Box_::pin(crate::GioFuture::new(self, move |obj, send| { 207 let cancellable = Cancellable::new(); 208 obj.fill_async(count, io_priority, Some(&cancellable), move |res| { 209 send.resolve(res); 210 }); 211 212 cancellable 213 })) 214 } 215 get_available(&self) -> usize216 fn get_available(&self) -> usize { 217 unsafe { gio_sys::g_buffered_input_stream_get_available(self.as_ref().to_glib_none().0) } 218 } 219 get_buffer_size(&self) -> usize220 fn get_buffer_size(&self) -> usize { 221 unsafe { gio_sys::g_buffered_input_stream_get_buffer_size(self.as_ref().to_glib_none().0) } 222 } 223 peek_buffer(&self) -> Vec<u8>224 fn peek_buffer(&self) -> Vec<u8> { 225 unsafe { 226 let mut count = mem::MaybeUninit::uninit(); 227 let ret = FromGlibContainer::from_glib_none_num( 228 gio_sys::g_buffered_input_stream_peek_buffer( 229 self.as_ref().to_glib_none().0, 230 count.as_mut_ptr(), 231 ), 232 count.assume_init() as usize, 233 ); 234 ret 235 } 236 } 237 read_byte<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<i32, glib::Error>238 fn read_byte<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<i32, glib::Error> { 239 unsafe { 240 let mut error = ptr::null_mut(); 241 let ret = gio_sys::g_buffered_input_stream_read_byte( 242 self.as_ref().to_glib_none().0, 243 cancellable.map(|p| p.as_ref()).to_glib_none().0, 244 &mut error, 245 ); 246 if error.is_null() { 247 Ok(ret) 248 } else { 249 Err(from_glib_full(error)) 250 } 251 } 252 } 253 set_buffer_size(&self, size: usize)254 fn set_buffer_size(&self, size: usize) { 255 unsafe { 256 gio_sys::g_buffered_input_stream_set_buffer_size(self.as_ref().to_glib_none().0, size); 257 } 258 } 259 connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId260 fn connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { 261 unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + 'static>( 262 this: *mut gio_sys::GBufferedInputStream, 263 _param_spec: glib_sys::gpointer, 264 f: glib_sys::gpointer, 265 ) where 266 P: IsA<BufferedInputStream>, 267 { 268 let f: &F = &*(f as *const F); 269 f(&BufferedInputStream::from_glib_borrow(this).unsafe_cast()) 270 } 271 unsafe { 272 let f: Box_<F> = Box_::new(f); 273 connect_raw( 274 self.as_ptr() as *mut _, 275 b"notify::buffer-size\0".as_ptr() as *const _, 276 Some(transmute(notify_buffer_size_trampoline::<Self, F> as usize)), 277 Box_::into_raw(f), 278 ) 279 } 280 } 281 } 282 283 impl fmt::Display for BufferedInputStream { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result284 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 285 write!(f, "BufferedInputStream") 286 } 287 } 288