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

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

glib_wrapper! {
    /// A `ThreadedSocketService` is a simple subclass of `SocketService`
    /// that handles incoming connections by creating a worker thread and
    /// dispatching the connection to it by emitting the
    /// `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` from accepting
    /// new connections when all threads are busy.
    ///
    /// As with `SocketService`, you may connect to `ThreadedSocketService::run`,
    /// or subclass and override the default handler.
    ///
    /// # Implements
    ///
    /// [`ThreadedSocketServiceExt`](trait.ThreadedSocketServiceExt.html), [`SocketServiceExt`](trait.SocketServiceExt.html), [`SocketListenerExt`](trait.SocketListenerExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`SocketListenerExtManual`](prelude/trait.SocketListenerExtManual.html)
    pub struct ThreadedSocketService(Object<gio_sys::GThreadedSocketService, gio_sys::GThreadedSocketServiceClass, ThreadedSocketServiceClass>) @extends SocketService, SocketListener;

    match fn {
        get_type => || gio_sys::g_threaded_socket_service_get_type(),
    }
}

impl ThreadedSocketService {
    /// Creates a new `ThreadedSocketService` with no listeners. Listeners
    /// must be added with one of the `SocketListener` "add" methods.
    /// ## `max_threads`
    /// the maximal number of threads to execute concurrently
    ///  handling incoming clients, -1 means no limit
    ///
    /// # Returns
    ///
    /// a new `SocketService`.
    pub fn new(max_threads: i32) -> ThreadedSocketService {
        unsafe {
            SocketService::from_glib_full(gio_sys::g_threaded_socket_service_new(max_threads))
                .unsafe_cast()
        }
    }
}

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

/// Trait containing all `ThreadedSocketService` methods.
///
/// # Implementors
///
/// [`ThreadedSocketService`](struct.ThreadedSocketService.html)
pub trait ThreadedSocketServiceExt: 'static {
    fn get_property_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` object.
    /// ## `source_object`
    /// the source_object passed to `SocketListenerExt::add_address`.
    ///
    /// # Returns
    ///
    /// `true` to stop further signal handlers from being called
    fn connect_run<F: Fn(&Self, &SocketConnection, &glib::Object) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

impl<O: IsA<ThreadedSocketService>> ThreadedSocketServiceExt for O {
    fn get_property_max_threads(&self) -> i32 {
        unsafe {
            let mut value = Value::from_type(<i32 as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::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")
                .unwrap()
        }
    }

    fn connect_run<F: Fn(&Self, &SocketConnection, &glib::Object) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn run_trampoline<
            P,
            F: Fn(&P, &SocketConnection, &glib::Object) -> bool + 'static,
        >(
            this: *mut gio_sys::GThreadedSocketService,
            connection: *mut gio_sys::GSocketConnection,
            source_object: *mut gobject_sys::GObject,
            f: glib_sys::gpointer,
        ) -> glib_sys::gboolean
        where
            P: IsA<ThreadedSocketService>,
        {
            let f: &F = &*(f as *const F);
            f(
                &ThreadedSocketService::from_glib_borrow(this).unsafe_cast(),
                &from_glib_borrow(connection),
                &from_glib_borrow(source_object),
            )
            .to_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(run_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }
}

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