gio/auto/socket_service.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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
// 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, SocketConnection, SocketListener};
use glib::{
prelude::*,
signal::{connect_raw, SignalHandlerId},
translate::*,
};
use std::boxed::Box as Box_;
glib::wrapper! {
/// A `GSocketService` is an object that represents a service that
/// is provided to the network or over local sockets. When a new
/// connection is made to the service the [`incoming`][struct@crate::SocketService#incoming]
/// signal is emitted.
///
/// A `GSocketService` is a subclass of [`SocketListener`][crate::SocketListener] and you need
/// to add the addresses you want to accept connections on with the
/// [`SocketListener`][crate::SocketListener] APIs.
///
/// There are two options for implementing a network service based on
/// `GSocketService`. The first is to create the service using
/// [`new()`][Self::new()] and to connect to the
/// [`incoming`][struct@crate::SocketService#incoming] signal. The second is to subclass
/// `GSocketService` and override the default signal handler implementation.
///
/// In either case, the handler must immediately return, or else it
/// will block additional incoming connections from being serviced.
/// If you are interested in writing connection handlers that contain
/// blocking code then see [`ThreadedSocketService`][crate::ThreadedSocketService].
///
/// The socket service runs on the main loop of the
/// thread-default context (see
/// [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()]) of the thread it is
/// created in, and is not threadsafe in general. However, the calls to start and
/// stop the service are thread-safe so these can be used from threads that
/// handle incoming clients.
///
/// ## Properties
///
///
/// #### `active`
/// Whether the service is currently accepting connections.
///
/// Readable | Writeable | Construct
/// <details><summary><h4>SocketListener</h4></summary>
///
///
/// #### `listen-backlog`
/// The number of outstanding connections in the listen queue.
///
/// Readable | Writeable | Construct
/// </details>
///
/// ## Signals
///
///
/// #### `incoming`
/// The ::incoming signal is emitted when a new incoming connection
/// to @service needs to be handled. The handler must initiate the
/// handling of @connection, but may not block; in essence,
/// asynchronous operations must be used.
///
/// @connection will be unreffed once the signal handler returns,
/// so you need to ref it yourself if you are planning to use it.
///
///
/// <details><summary><h4>SocketListener</h4></summary>
///
///
/// #### `event`
/// Emitted when @listener's activity on @socket changes state.
/// Note that when @listener is used to listen on both IPv4 and
/// IPv6, a separate set of signals will be emitted for each, and
/// the order they happen in is undefined.
///
///
/// </details>
///
/// # Implements
///
/// [`SocketServiceExt`][trait@crate::prelude::SocketServiceExt], [`SocketListenerExt`][trait@crate::prelude::SocketListenerExt], [`trait@glib::ObjectExt`], [`SocketListenerExtManual`][trait@crate::prelude::SocketListenerExtManual]
#[doc(alias = "GSocketService")]
pub struct SocketService(Object<ffi::GSocketService, ffi::GSocketServiceClass>) @extends SocketListener;
match fn {
type_ => || ffi::g_socket_service_get_type(),
}
}
impl SocketService {
pub const NONE: Option<&'static SocketService> = None;
/// Creates a new #GSocketService with no sockets to listen for.
/// New listeners can be added with e.g. g_socket_listener_add_address()
/// or g_socket_listener_add_inet_port().
///
/// New services are created active, there is no need to call
/// g_socket_service_start(), unless g_socket_service_stop() has been
/// called before.
///
/// # Returns
///
/// a new #GSocketService.
#[doc(alias = "g_socket_service_new")]
pub fn new() -> SocketService {
unsafe { from_glib_full(ffi::g_socket_service_new()) }
}
}
impl Default for SocketService {
fn default() -> Self {
Self::new()
}
}
mod sealed {
pub trait Sealed {}
impl<T: super::IsA<super::SocketService>> Sealed for T {}
}
/// Trait containing all [`struct@SocketService`] methods.
///
/// # Implementors
///
/// [`SocketService`][struct@crate::SocketService], [`ThreadedSocketService`][struct@crate::ThreadedSocketService]
pub trait SocketServiceExt: IsA<SocketService> + sealed::Sealed + 'static {
/// Check whether the service is active or not. An active
/// service will accept new clients that connect, while
/// a non-active service will let connecting clients queue
/// up until the service is started.
///
/// # Returns
///
/// [`true`] if the service is active, [`false`] otherwise
#[doc(alias = "g_socket_service_is_active")]
#[doc(alias = "active")]
fn is_active(&self) -> bool {
unsafe {
from_glib(ffi::g_socket_service_is_active(
self.as_ref().to_glib_none().0,
))
}
}
/// Restarts the service, i.e. start accepting connections
/// from the added sockets when the mainloop runs. This only needs
/// to be called after the service has been stopped from
/// g_socket_service_stop().
///
/// This call is thread-safe, so it may be called from a thread
/// handling an incoming client request.
#[doc(alias = "g_socket_service_start")]
fn start(&self) {
unsafe {
ffi::g_socket_service_start(self.as_ref().to_glib_none().0);
}
}
/// Stops the service, i.e. stops accepting connections
/// from the added sockets when the mainloop runs.
///
/// This call is thread-safe, so it may be called from a thread
/// handling an incoming client request.
///
/// Note that this only stops accepting new connections; it does not
/// close the listening sockets, and you can call
/// g_socket_service_start() again later to begin listening again. To
/// close the listening sockets, call g_socket_listener_close(). (This
/// will happen automatically when the #GSocketService is finalized.)
///
/// This must be called before calling g_socket_listener_close() as
/// the socket service will start accepting connections immediately
/// when a new socket is added.
#[doc(alias = "g_socket_service_stop")]
fn stop(&self) {
unsafe {
ffi::g_socket_service_stop(self.as_ref().to_glib_none().0);
}
}
/// Whether the service is currently accepting connections.
fn set_active(&self, active: bool) {
ObjectExt::set_property(self.as_ref(), "active", active)
}
/// The ::incoming signal is emitted when a new incoming connection
/// to @service needs to be handled. The handler must initiate the
/// handling of @connection, but may not block; in essence,
/// asynchronous operations must be used.
///
/// @connection will be unreffed once the signal handler returns,
/// so you need to ref it yourself if you are planning to use it.
/// ## `connection`
/// a new #GSocketConnection object
/// ## `source_object`
/// the source_object passed to
/// g_socket_listener_add_address()
///
/// # Returns
///
/// [`true`] to stop other handlers from being called
#[doc(alias = "incoming")]
fn connect_incoming<
F: Fn(&Self, &SocketConnection, Option<&glib::Object>) -> bool + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn incoming_trampoline<
P: IsA<SocketService>,
F: Fn(&P, &SocketConnection, Option<&glib::Object>) -> bool + 'static,
>(
this: *mut ffi::GSocketService,
connection: *mut ffi::GSocketConnection,
source_object: *mut glib::gobject_ffi::GObject,
f: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
let f: &F = &*(f as *const F);
f(
SocketService::from_glib_borrow(this).unsafe_cast_ref(),
&from_glib_borrow(connection),
Option::<glib::Object>::from_glib_borrow(source_object)
.as_ref()
.as_ref(),
)
.into_glib()
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"incoming\0".as_ptr() as *const _,
Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
incoming_trampoline::<Self, F> as *const (),
)),
Box_::into_raw(f),
)
}
}
#[doc(alias = "active")]
fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_active_trampoline<
P: IsA<SocketService>,
F: Fn(&P) + 'static,
>(
this: *mut ffi::GSocketService,
_param_spec: glib::ffi::gpointer,
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(SocketService::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"notify::active\0".as_ptr() as *const _,
Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
notify_active_trampoline::<Self, F> as *const (),
)),
Box_::into_raw(f),
)
}
}
}
impl<O: IsA<SocketService>> SocketServiceExt for O {}