gio/auto/

socket_service.rs

// 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 {}