gio/auto/socket_address_enumerator.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
use crate::{ffi, AsyncResult, Cancellable, SocketAddress};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};
glib::wrapper! {
/// `GSocketAddressEnumerator` is an enumerator type for
/// [`SocketAddress`][crate::SocketAddress] instances. It is returned by enumeration functions
/// such as [`SocketConnectableExt::enumerate()`][crate::prelude::SocketConnectableExt::enumerate()], which returns a
/// `GSocketAddressEnumerator` to list each [`SocketAddress`][crate::SocketAddress] which could
/// be used to connect to that [`SocketConnectable`][crate::SocketConnectable].
///
/// Enumeration is typically a blocking operation, so the asynchronous methods
/// [`SocketAddressEnumeratorExt::next_async()`][crate::prelude::SocketAddressEnumeratorExt::next_async()] and
/// `Gio::SocketAddressEnumerator::next_finish()` should be used where
/// possible.
///
/// Each `GSocketAddressEnumerator` can only be enumerated once. Once
/// [`SocketAddressEnumeratorExt::next()`][crate::prelude::SocketAddressEnumeratorExt::next()] has returned `NULL`, further
/// enumeration with that `GSocketAddressEnumerator` is not possible, and it can
/// be unreffed.
///
/// This is an Abstract Base Class, you cannot instantiate it.
///
/// # Implements
///
/// [`SocketAddressEnumeratorExt`][trait@crate::prelude::SocketAddressEnumeratorExt], [`trait@glib::ObjectExt`]
#[doc(alias = "GSocketAddressEnumerator")]
pub struct SocketAddressEnumerator(Object<ffi::GSocketAddressEnumerator, ffi::GSocketAddressEnumeratorClass>);
match fn {
type_ => || ffi::g_socket_address_enumerator_get_type(),
}
}
impl SocketAddressEnumerator {
pub const NONE: Option<&'static SocketAddressEnumerator> = None;
}
mod sealed {
pub trait Sealed {}
impl<T: super::IsA<super::SocketAddressEnumerator>> Sealed for T {}
}
/// Trait containing all [`struct@SocketAddressEnumerator`] methods.
///
/// # Implementors
///
/// [`SocketAddressEnumerator`][struct@crate::SocketAddressEnumerator]
pub trait SocketAddressEnumeratorExt:
IsA<SocketAddressEnumerator> + sealed::Sealed + 'static
{
/// Retrieves the next #GSocketAddress from @self. Note that this
/// may block for some amount of time. (Eg, a #GNetworkAddress may need
/// to do a DNS lookup before it can return an address.) Use
/// g_socket_address_enumerator_next_async() if you need to avoid
/// blocking.
///
/// If @self is expected to yield addresses, but for some reason
/// is unable to (eg, because of a DNS error), then the first call to
/// g_socket_address_enumerator_next() will return an appropriate error
/// in *@error. However, if the first call to
/// g_socket_address_enumerator_next() succeeds, then any further
/// internal errors (other than @cancellable being triggered) will be
/// ignored.
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to ignore.
///
/// # Returns
///
/// a #GSocketAddress (owned by the caller), or [`None`] on
/// error (in which case *@error will be set) or if there are no
/// more addresses.
#[doc(alias = "g_socket_address_enumerator_next")]
fn next(
&self,
cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<Option<SocketAddress>, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::g_socket_address_enumerator_next(
self.as_ref().to_glib_none().0,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
/// Asynchronously retrieves the next #GSocketAddress from @self
/// and then calls @callback, which must call
/// g_socket_address_enumerator_next_finish() to get the result.
///
/// It is an error to call this multiple times before the previous callback has finished.
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to ignore.
/// ## `callback`
/// a #GAsyncReadyCallback to call
/// when the request is satisfied
#[doc(alias = "g_socket_address_enumerator_next_async")]
fn next_async<P: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static>(
&self,
cancellable: Option<&impl IsA<Cancellable>>,
callback: P,
) {
let main_context = glib::MainContext::ref_thread_default();
let is_main_context_owner = main_context.is_owner();
let has_acquired_main_context = (!is_main_context_owner)
.then(|| main_context.acquire().ok())
.flatten();
assert!(
is_main_context_owner || has_acquired_main_context.is_some(),
"Async operations only allowed if the thread is owning the MainContext"
);
let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::new(glib::thread_guard::ThreadGuard::new(callback));
unsafe extern "C" fn next_async_trampoline<
P: FnOnce(Result<Option<SocketAddress>, glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let ret = ffi::g_socket_address_enumerator_next_finish(
_source_object as *mut _,
res,
&mut error,
);
let result = if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
};
let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = next_async_trampoline::<P>;
unsafe {
ffi::g_socket_address_enumerator_next_async(
self.as_ref().to_glib_none().0,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
fn next_future(
&self,
) -> Pin<
Box_<
dyn std::future::Future<Output = Result<Option<SocketAddress>, glib::Error>> + 'static,
>,
> {
Box_::pin(crate::GioFuture::new(
self,
move |obj, cancellable, send| {
obj.next_async(Some(cancellable), move |res| {
send.resolve(res);
});
},
))
}
}
impl<O: IsA<SocketAddressEnumerator>> SocketAddressEnumeratorExt for O {}