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

// 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::SocketConnection;
use crate::SocketListener;
use crate::SocketService;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// A [`ThreadedSocketService`][crate::ThreadedSocketService] is a simple subclass of [`SocketService`][crate::SocketService]
    /// that handles incoming connections by creating a worker thread and
    /// dispatching the connection to it by emitting the
    /// `signal::ThreadedSocketService::run` signal in the new thread.
    ///
    /// The signal handler may perform blocking IO and need not return
    /// until the connection is closed.
    ///
    /// The service is implemented using a thread pool, so there is a
    /// limited amount of threads available to serve incoming requests.
    /// The service automatically stops the [`SocketService`][crate::SocketService] from accepting
    /// new connections when all threads are busy.
    ///
    /// As with [`SocketService`][crate::SocketService], you may connect to `signal::ThreadedSocketService::run`,
    /// or subclass and override the default handler.
    ///
    /// # Implements
    ///
    /// [`ThreadedSocketServiceExt`][trait@crate::prelude::ThreadedSocketServiceExt], [`SocketServiceExt`][trait@crate::prelude::SocketServiceExt], [`SocketListenerExt`][trait@crate::prelude::SocketListenerExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GThreadedSocketService")]
    pub struct ThreadedSocketService(Object<ffi::GThreadedSocketService, ffi::GThreadedSocketServiceClass>) @extends SocketService, SocketListener;

    match fn {
        type_ => || ffi::g_threaded_socket_service_get_type(),
    }
}

pub const NONE_THREADED_SOCKET_SERVICE: Option<&ThreadedSocketService> = None;

/// Trait containing all [`struct@ThreadedSocketService`] methods.
///
/// # Implementors
///
/// [`ThreadedSocketService`][struct@crate::ThreadedSocketService]
pub trait ThreadedSocketServiceExt: 'static {
    #[doc(alias = "max-threads")]
    fn max_threads(&self) -> i32;

    /// The ::run signal is emitted in a worker thread in response to an
    /// incoming connection. This thread is dedicated to handling
    /// `connection` and may perform blocking IO. The signal handler need
    /// not return until the connection is closed.
    /// ## `connection`
    /// a new [`SocketConnection`][crate::SocketConnection] object.
    /// ## `source_object`
    /// the source_object passed to [`SocketListenerExt::add_address()`][crate::prelude::SocketListenerExt::add_address()].
    ///
    /// # Returns
    ///
    /// [`true`] to stop further signal handlers from being called
    #[doc(alias = "run")]
    fn connect_run<F: Fn(&Self, &SocketConnection, Option<&glib::Object>) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

impl<O: IsA<ThreadedSocketService>> ThreadedSocketServiceExt for O {
    fn max_threads(&self) -> i32 {
        unsafe {
            let mut value = glib::Value::from_type(<i32 as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"max-threads\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `max-threads` getter")
        }
    }

    fn connect_run<F: Fn(&Self, &SocketConnection, Option<&glib::Object>) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn run_trampoline<
            P: IsA<ThreadedSocketService>,
            F: Fn(&P, &SocketConnection, Option<&glib::Object>) -> bool + 'static,
        >(
            this: *mut ffi::GThreadedSocketService,
            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(
                ThreadedSocketService::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"run\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    run_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for ThreadedSocketService {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("ThreadedSocketService")
    }
}