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 crate::AsyncResult; 6 use crate::Cancellable; 7 use crate::InetAddress; 8 #[cfg(any(feature = "v2_60", feature = "dox"))] 9 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] 10 use crate::ResolverNameLookupFlags; 11 use crate::ResolverRecordType; 12 use crate::SrvTarget; 13 use glib::object::Cast; 14 use glib::object::IsA; 15 use glib::signal::connect_raw; 16 use glib::signal::SignalHandlerId; 17 use glib::translate::*; 18 use std::boxed::Box as Box_; 19 use std::fmt; 20 use std::mem::transmute; 21 use std::pin::Pin; 22 use std::ptr; 23 24 glib::wrapper! { 25 #[doc(alias = "GResolver")] 26 pub struct Resolver(Object<ffi::GResolver, ffi::GResolverClass>); 27 28 match fn { 29 type_ => || ffi::g_resolver_get_type(), 30 } 31 } 32 33 impl Resolver { 34 //#[doc(alias = "g_resolver_free_addresses")] 35 //pub fn free_addresses(addresses: /*Unimplemented*/&[&Fundamental: Pointer]) { 36 // unsafe { TODO: call ffi:g_resolver_free_addresses() } 37 //} 38 39 //#[doc(alias = "g_resolver_free_targets")] 40 //pub fn free_targets(targets: /*Unimplemented*/&[&Fundamental: Pointer]) { 41 // unsafe { TODO: call ffi:g_resolver_free_targets() } 42 //} 43 44 #[doc(alias = "g_resolver_get_default")] 45 #[doc(alias = "get_default")] default() -> Resolver46 pub fn default() -> Resolver { 47 unsafe { from_glib_full(ffi::g_resolver_get_default()) } 48 } 49 } 50 51 pub const NONE_RESOLVER: Option<&Resolver> = None; 52 53 pub trait ResolverExt: 'static { 54 #[doc(alias = "g_resolver_lookup_by_address")] lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>( &self, address: &P, cancellable: Option<&Q>, ) -> Result<glib::GString, glib::Error>55 fn lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>( 56 &self, 57 address: &P, 58 cancellable: Option<&Q>, 59 ) -> Result<glib::GString, glib::Error>; 60 61 #[doc(alias = "g_resolver_lookup_by_address_async")] lookup_by_address_async< P: IsA<InetAddress>, Q: IsA<Cancellable>, R: FnOnce(Result<glib::GString, glib::Error>) + Send + 'static, >( &self, address: &P, cancellable: Option<&Q>, callback: R, )62 fn lookup_by_address_async< 63 P: IsA<InetAddress>, 64 Q: IsA<Cancellable>, 65 R: FnOnce(Result<glib::GString, glib::Error>) + Send + 'static, 66 >( 67 &self, 68 address: &P, 69 cancellable: Option<&Q>, 70 callback: R, 71 ); 72 lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>( &self, address: &P, ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>73 fn lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>( 74 &self, 75 address: &P, 76 ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>; 77 78 #[doc(alias = "g_resolver_lookup_by_name")] lookup_by_name<P: IsA<Cancellable>>( &self, hostname: &str, cancellable: Option<&P>, ) -> Result<Vec<InetAddress>, glib::Error>79 fn lookup_by_name<P: IsA<Cancellable>>( 80 &self, 81 hostname: &str, 82 cancellable: Option<&P>, 83 ) -> Result<Vec<InetAddress>, glib::Error>; 84 85 #[doc(alias = "g_resolver_lookup_by_name_async")] lookup_by_name_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, >( &self, hostname: &str, cancellable: Option<&P>, callback: Q, )86 fn lookup_by_name_async< 87 P: IsA<Cancellable>, 88 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 89 >( 90 &self, 91 hostname: &str, 92 cancellable: Option<&P>, 93 callback: Q, 94 ); 95 lookup_by_name_async_future( &self, hostname: &str, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>96 fn lookup_by_name_async_future( 97 &self, 98 hostname: &str, 99 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>; 100 101 #[cfg(any(feature = "v2_60", feature = "dox"))] 102 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] 103 #[doc(alias = "g_resolver_lookup_by_name_with_flags")] lookup_by_name_with_flags<P: IsA<Cancellable>>( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&P>, ) -> Result<Vec<InetAddress>, glib::Error>104 fn lookup_by_name_with_flags<P: IsA<Cancellable>>( 105 &self, 106 hostname: &str, 107 flags: ResolverNameLookupFlags, 108 cancellable: Option<&P>, 109 ) -> Result<Vec<InetAddress>, glib::Error>; 110 111 #[cfg(any(feature = "v2_60", feature = "dox"))] 112 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] 113 #[doc(alias = "g_resolver_lookup_by_name_with_flags_async")] lookup_by_name_with_flags_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, >( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&P>, callback: Q, )114 fn lookup_by_name_with_flags_async< 115 P: IsA<Cancellable>, 116 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 117 >( 118 &self, 119 hostname: &str, 120 flags: ResolverNameLookupFlags, 121 cancellable: Option<&P>, 122 callback: Q, 123 ); 124 125 #[cfg(any(feature = "v2_60", feature = "dox"))] 126 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] lookup_by_name_with_flags_async_future( &self, hostname: &str, flags: ResolverNameLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>127 fn lookup_by_name_with_flags_async_future( 128 &self, 129 hostname: &str, 130 flags: ResolverNameLookupFlags, 131 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>; 132 133 #[doc(alias = "g_resolver_lookup_records")] lookup_records<P: IsA<Cancellable>>( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&P>, ) -> Result<Vec<glib::Variant>, glib::Error>134 fn lookup_records<P: IsA<Cancellable>>( 135 &self, 136 rrname: &str, 137 record_type: ResolverRecordType, 138 cancellable: Option<&P>, 139 ) -> Result<Vec<glib::Variant>, glib::Error>; 140 141 #[doc(alias = "g_resolver_lookup_records_async")] lookup_records_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static, >( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&P>, callback: Q, )142 fn lookup_records_async< 143 P: IsA<Cancellable>, 144 Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static, 145 >( 146 &self, 147 rrname: &str, 148 record_type: ResolverRecordType, 149 cancellable: Option<&P>, 150 callback: Q, 151 ); 152 lookup_records_async_future( &self, rrname: &str, record_type: ResolverRecordType, ) -> Pin< Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>, >153 fn lookup_records_async_future( 154 &self, 155 rrname: &str, 156 record_type: ResolverRecordType, 157 ) -> Pin< 158 Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>, 159 >; 160 161 #[doc(alias = "g_resolver_lookup_service")] lookup_service<P: IsA<Cancellable>>( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&P>, ) -> Result<Vec<SrvTarget>, glib::Error>162 fn lookup_service<P: IsA<Cancellable>>( 163 &self, 164 service: &str, 165 protocol: &str, 166 domain: &str, 167 cancellable: Option<&P>, 168 ) -> Result<Vec<SrvTarget>, glib::Error>; 169 170 #[doc(alias = "g_resolver_lookup_service_async")] lookup_service_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static, >( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&P>, callback: Q, )171 fn lookup_service_async< 172 P: IsA<Cancellable>, 173 Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static, 174 >( 175 &self, 176 service: &str, 177 protocol: &str, 178 domain: &str, 179 cancellable: Option<&P>, 180 callback: Q, 181 ); 182 lookup_service_async_future( &self, service: &str, protocol: &str, domain: &str, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>183 fn lookup_service_async_future( 184 &self, 185 service: &str, 186 protocol: &str, 187 domain: &str, 188 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>; 189 190 #[doc(alias = "g_resolver_set_default")] set_default(&self)191 fn set_default(&self); 192 193 #[doc(alias = "reload")] connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId194 fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; 195 } 196 197 impl<O: IsA<Resolver>> ResolverExt for O { lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>( &self, address: &P, cancellable: Option<&Q>, ) -> Result<glib::GString, glib::Error>198 fn lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>( 199 &self, 200 address: &P, 201 cancellable: Option<&Q>, 202 ) -> Result<glib::GString, glib::Error> { 203 unsafe { 204 let mut error = ptr::null_mut(); 205 let ret = ffi::g_resolver_lookup_by_address( 206 self.as_ref().to_glib_none().0, 207 address.as_ref().to_glib_none().0, 208 cancellable.map(|p| p.as_ref()).to_glib_none().0, 209 &mut error, 210 ); 211 if error.is_null() { 212 Ok(from_glib_full(ret)) 213 } else { 214 Err(from_glib_full(error)) 215 } 216 } 217 } 218 lookup_by_address_async< P: IsA<InetAddress>, Q: IsA<Cancellable>, R: FnOnce(Result<glib::GString, glib::Error>) + Send + 'static, >( &self, address: &P, cancellable: Option<&Q>, callback: R, )219 fn lookup_by_address_async< 220 P: IsA<InetAddress>, 221 Q: IsA<Cancellable>, 222 R: FnOnce(Result<glib::GString, glib::Error>) + Send + 'static, 223 >( 224 &self, 225 address: &P, 226 cancellable: Option<&Q>, 227 callback: R, 228 ) { 229 let user_data: Box_<R> = Box_::new(callback); 230 unsafe extern "C" fn lookup_by_address_async_trampoline< 231 R: FnOnce(Result<glib::GString, glib::Error>) + Send + 'static, 232 >( 233 _source_object: *mut glib::gobject_ffi::GObject, 234 res: *mut crate::ffi::GAsyncResult, 235 user_data: glib::ffi::gpointer, 236 ) { 237 let mut error = ptr::null_mut(); 238 let ret = 239 ffi::g_resolver_lookup_by_address_finish(_source_object as *mut _, res, &mut error); 240 let result = if error.is_null() { 241 Ok(from_glib_full(ret)) 242 } else { 243 Err(from_glib_full(error)) 244 }; 245 let callback: Box_<R> = Box_::from_raw(user_data as *mut _); 246 callback(result); 247 } 248 let callback = lookup_by_address_async_trampoline::<R>; 249 unsafe { 250 ffi::g_resolver_lookup_by_address_async( 251 self.as_ref().to_glib_none().0, 252 address.as_ref().to_glib_none().0, 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 lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>( &self, address: &P, ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>260 fn lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>( 261 &self, 262 address: &P, 263 ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>> 264 { 265 let address = address.clone(); 266 Box_::pin(crate::GioFuture::new( 267 self, 268 move |obj, cancellable, send| { 269 obj.lookup_by_address_async(&address, Some(cancellable), move |res| { 270 send.resolve(res); 271 }); 272 }, 273 )) 274 } 275 lookup_by_name<P: IsA<Cancellable>>( &self, hostname: &str, cancellable: Option<&P>, ) -> Result<Vec<InetAddress>, glib::Error>276 fn lookup_by_name<P: IsA<Cancellable>>( 277 &self, 278 hostname: &str, 279 cancellable: Option<&P>, 280 ) -> Result<Vec<InetAddress>, glib::Error> { 281 unsafe { 282 let mut error = ptr::null_mut(); 283 let ret = ffi::g_resolver_lookup_by_name( 284 self.as_ref().to_glib_none().0, 285 hostname.to_glib_none().0, 286 cancellable.map(|p| p.as_ref()).to_glib_none().0, 287 &mut error, 288 ); 289 if error.is_null() { 290 Ok(FromGlibPtrContainer::from_glib_full(ret)) 291 } else { 292 Err(from_glib_full(error)) 293 } 294 } 295 } 296 lookup_by_name_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, >( &self, hostname: &str, cancellable: Option<&P>, callback: Q, )297 fn lookup_by_name_async< 298 P: IsA<Cancellable>, 299 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 300 >( 301 &self, 302 hostname: &str, 303 cancellable: Option<&P>, 304 callback: Q, 305 ) { 306 let user_data: Box_<Q> = Box_::new(callback); 307 unsafe extern "C" fn lookup_by_name_async_trampoline< 308 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 309 >( 310 _source_object: *mut glib::gobject_ffi::GObject, 311 res: *mut crate::ffi::GAsyncResult, 312 user_data: glib::ffi::gpointer, 313 ) { 314 let mut error = ptr::null_mut(); 315 let ret = 316 ffi::g_resolver_lookup_by_name_finish(_source_object as *mut _, res, &mut error); 317 let result = if error.is_null() { 318 Ok(FromGlibPtrContainer::from_glib_full(ret)) 319 } else { 320 Err(from_glib_full(error)) 321 }; 322 let callback: Box_<Q> = Box_::from_raw(user_data as *mut _); 323 callback(result); 324 } 325 let callback = lookup_by_name_async_trampoline::<Q>; 326 unsafe { 327 ffi::g_resolver_lookup_by_name_async( 328 self.as_ref().to_glib_none().0, 329 hostname.to_glib_none().0, 330 cancellable.map(|p| p.as_ref()).to_glib_none().0, 331 Some(callback), 332 Box_::into_raw(user_data) as *mut _, 333 ); 334 } 335 } 336 lookup_by_name_async_future( &self, hostname: &str, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>337 fn lookup_by_name_async_future( 338 &self, 339 hostname: &str, 340 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>> 341 { 342 let hostname = String::from(hostname); 343 Box_::pin(crate::GioFuture::new( 344 self, 345 move |obj, cancellable, send| { 346 obj.lookup_by_name_async(&hostname, Some(cancellable), move |res| { 347 send.resolve(res); 348 }); 349 }, 350 )) 351 } 352 353 #[cfg(any(feature = "v2_60", feature = "dox"))] 354 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] lookup_by_name_with_flags<P: IsA<Cancellable>>( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&P>, ) -> Result<Vec<InetAddress>, glib::Error>355 fn lookup_by_name_with_flags<P: IsA<Cancellable>>( 356 &self, 357 hostname: &str, 358 flags: ResolverNameLookupFlags, 359 cancellable: Option<&P>, 360 ) -> Result<Vec<InetAddress>, glib::Error> { 361 unsafe { 362 let mut error = ptr::null_mut(); 363 let ret = ffi::g_resolver_lookup_by_name_with_flags( 364 self.as_ref().to_glib_none().0, 365 hostname.to_glib_none().0, 366 flags.into_glib(), 367 cancellable.map(|p| p.as_ref()).to_glib_none().0, 368 &mut error, 369 ); 370 if error.is_null() { 371 Ok(FromGlibPtrContainer::from_glib_full(ret)) 372 } else { 373 Err(from_glib_full(error)) 374 } 375 } 376 } 377 378 #[cfg(any(feature = "v2_60", feature = "dox"))] 379 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] lookup_by_name_with_flags_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, >( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&P>, callback: Q, )380 fn lookup_by_name_with_flags_async< 381 P: IsA<Cancellable>, 382 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 383 >( 384 &self, 385 hostname: &str, 386 flags: ResolverNameLookupFlags, 387 cancellable: Option<&P>, 388 callback: Q, 389 ) { 390 let user_data: Box_<Q> = Box_::new(callback); 391 unsafe extern "C" fn lookup_by_name_with_flags_async_trampoline< 392 Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static, 393 >( 394 _source_object: *mut glib::gobject_ffi::GObject, 395 res: *mut crate::ffi::GAsyncResult, 396 user_data: glib::ffi::gpointer, 397 ) { 398 let mut error = ptr::null_mut(); 399 let ret = ffi::g_resolver_lookup_by_name_with_flags_finish( 400 _source_object as *mut _, 401 res, 402 &mut error, 403 ); 404 let result = if error.is_null() { 405 Ok(FromGlibPtrContainer::from_glib_full(ret)) 406 } else { 407 Err(from_glib_full(error)) 408 }; 409 let callback: Box_<Q> = Box_::from_raw(user_data as *mut _); 410 callback(result); 411 } 412 let callback = lookup_by_name_with_flags_async_trampoline::<Q>; 413 unsafe { 414 ffi::g_resolver_lookup_by_name_with_flags_async( 415 self.as_ref().to_glib_none().0, 416 hostname.to_glib_none().0, 417 flags.into_glib(), 418 cancellable.map(|p| p.as_ref()).to_glib_none().0, 419 Some(callback), 420 Box_::into_raw(user_data) as *mut _, 421 ); 422 } 423 } 424 425 #[cfg(any(feature = "v2_60", feature = "dox"))] 426 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))] lookup_by_name_with_flags_async_future( &self, hostname: &str, flags: ResolverNameLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>427 fn lookup_by_name_with_flags_async_future( 428 &self, 429 hostname: &str, 430 flags: ResolverNameLookupFlags, 431 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>> 432 { 433 let hostname = String::from(hostname); 434 Box_::pin(crate::GioFuture::new( 435 self, 436 move |obj, cancellable, send| { 437 obj.lookup_by_name_with_flags_async( 438 &hostname, 439 flags, 440 Some(cancellable), 441 move |res| { 442 send.resolve(res); 443 }, 444 ); 445 }, 446 )) 447 } 448 lookup_records<P: IsA<Cancellable>>( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&P>, ) -> Result<Vec<glib::Variant>, glib::Error>449 fn lookup_records<P: IsA<Cancellable>>( 450 &self, 451 rrname: &str, 452 record_type: ResolverRecordType, 453 cancellable: Option<&P>, 454 ) -> Result<Vec<glib::Variant>, glib::Error> { 455 unsafe { 456 let mut error = ptr::null_mut(); 457 let ret = ffi::g_resolver_lookup_records( 458 self.as_ref().to_glib_none().0, 459 rrname.to_glib_none().0, 460 record_type.into_glib(), 461 cancellable.map(|p| p.as_ref()).to_glib_none().0, 462 &mut error, 463 ); 464 if error.is_null() { 465 Ok(FromGlibPtrContainer::from_glib_full(ret)) 466 } else { 467 Err(from_glib_full(error)) 468 } 469 } 470 } 471 lookup_records_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static, >( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&P>, callback: Q, )472 fn lookup_records_async< 473 P: IsA<Cancellable>, 474 Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static, 475 >( 476 &self, 477 rrname: &str, 478 record_type: ResolverRecordType, 479 cancellable: Option<&P>, 480 callback: Q, 481 ) { 482 let user_data: Box_<Q> = Box_::new(callback); 483 unsafe extern "C" fn lookup_records_async_trampoline< 484 Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static, 485 >( 486 _source_object: *mut glib::gobject_ffi::GObject, 487 res: *mut crate::ffi::GAsyncResult, 488 user_data: glib::ffi::gpointer, 489 ) { 490 let mut error = ptr::null_mut(); 491 let ret = 492 ffi::g_resolver_lookup_records_finish(_source_object as *mut _, res, &mut error); 493 let result = if error.is_null() { 494 Ok(FromGlibPtrContainer::from_glib_full(ret)) 495 } else { 496 Err(from_glib_full(error)) 497 }; 498 let callback: Box_<Q> = Box_::from_raw(user_data as *mut _); 499 callback(result); 500 } 501 let callback = lookup_records_async_trampoline::<Q>; 502 unsafe { 503 ffi::g_resolver_lookup_records_async( 504 self.as_ref().to_glib_none().0, 505 rrname.to_glib_none().0, 506 record_type.into_glib(), 507 cancellable.map(|p| p.as_ref()).to_glib_none().0, 508 Some(callback), 509 Box_::into_raw(user_data) as *mut _, 510 ); 511 } 512 } 513 lookup_records_async_future( &self, rrname: &str, record_type: ResolverRecordType, ) -> Pin< Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>, >514 fn lookup_records_async_future( 515 &self, 516 rrname: &str, 517 record_type: ResolverRecordType, 518 ) -> Pin< 519 Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>, 520 > { 521 let rrname = String::from(rrname); 522 Box_::pin(crate::GioFuture::new( 523 self, 524 move |obj, cancellable, send| { 525 obj.lookup_records_async(&rrname, record_type, Some(cancellable), move |res| { 526 send.resolve(res); 527 }); 528 }, 529 )) 530 } 531 lookup_service<P: IsA<Cancellable>>( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&P>, ) -> Result<Vec<SrvTarget>, glib::Error>532 fn lookup_service<P: IsA<Cancellable>>( 533 &self, 534 service: &str, 535 protocol: &str, 536 domain: &str, 537 cancellable: Option<&P>, 538 ) -> Result<Vec<SrvTarget>, glib::Error> { 539 unsafe { 540 let mut error = ptr::null_mut(); 541 let ret = ffi::g_resolver_lookup_service( 542 self.as_ref().to_glib_none().0, 543 service.to_glib_none().0, 544 protocol.to_glib_none().0, 545 domain.to_glib_none().0, 546 cancellable.map(|p| p.as_ref()).to_glib_none().0, 547 &mut error, 548 ); 549 if error.is_null() { 550 Ok(FromGlibPtrContainer::from_glib_full(ret)) 551 } else { 552 Err(from_glib_full(error)) 553 } 554 } 555 } 556 lookup_service_async< P: IsA<Cancellable>, Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static, >( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&P>, callback: Q, )557 fn lookup_service_async< 558 P: IsA<Cancellable>, 559 Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static, 560 >( 561 &self, 562 service: &str, 563 protocol: &str, 564 domain: &str, 565 cancellable: Option<&P>, 566 callback: Q, 567 ) { 568 let user_data: Box_<Q> = Box_::new(callback); 569 unsafe extern "C" fn lookup_service_async_trampoline< 570 Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static, 571 >( 572 _source_object: *mut glib::gobject_ffi::GObject, 573 res: *mut crate::ffi::GAsyncResult, 574 user_data: glib::ffi::gpointer, 575 ) { 576 let mut error = ptr::null_mut(); 577 let ret = 578 ffi::g_resolver_lookup_service_finish(_source_object as *mut _, res, &mut error); 579 let result = if error.is_null() { 580 Ok(FromGlibPtrContainer::from_glib_full(ret)) 581 } else { 582 Err(from_glib_full(error)) 583 }; 584 let callback: Box_<Q> = Box_::from_raw(user_data as *mut _); 585 callback(result); 586 } 587 let callback = lookup_service_async_trampoline::<Q>; 588 unsafe { 589 ffi::g_resolver_lookup_service_async( 590 self.as_ref().to_glib_none().0, 591 service.to_glib_none().0, 592 protocol.to_glib_none().0, 593 domain.to_glib_none().0, 594 cancellable.map(|p| p.as_ref()).to_glib_none().0, 595 Some(callback), 596 Box_::into_raw(user_data) as *mut _, 597 ); 598 } 599 } 600 lookup_service_async_future( &self, service: &str, protocol: &str, domain: &str, ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>601 fn lookup_service_async_future( 602 &self, 603 service: &str, 604 protocol: &str, 605 domain: &str, 606 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>> 607 { 608 let service = String::from(service); 609 let protocol = String::from(protocol); 610 let domain = String::from(domain); 611 Box_::pin(crate::GioFuture::new( 612 self, 613 move |obj, cancellable, send| { 614 obj.lookup_service_async( 615 &service, 616 &protocol, 617 &domain, 618 Some(cancellable), 619 move |res| { 620 send.resolve(res); 621 }, 622 ); 623 }, 624 )) 625 } 626 set_default(&self)627 fn set_default(&self) { 628 unsafe { 629 ffi::g_resolver_set_default(self.as_ref().to_glib_none().0); 630 } 631 } 632 connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId633 fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { 634 unsafe extern "C" fn reload_trampoline<P: IsA<Resolver>, F: Fn(&P) + 'static>( 635 this: *mut ffi::GResolver, 636 f: glib::ffi::gpointer, 637 ) { 638 let f: &F = &*(f as *const F); 639 f(Resolver::from_glib_borrow(this).unsafe_cast_ref()) 640 } 641 unsafe { 642 let f: Box_<F> = Box_::new(f); 643 connect_raw( 644 self.as_ptr() as *mut _, 645 b"reload\0".as_ptr() as *const _, 646 Some(transmute::<_, unsafe extern "C" fn()>( 647 reload_trampoline::<Self, F> as *const (), 648 )), 649 Box_::into_raw(f), 650 ) 651 } 652 } 653 } 654 655 impl fmt::Display for Resolver { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result656 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 657 f.write_str("Resolver") 658 } 659 } 660