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

// 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::{IOStream, SocketConnection};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// This is the subclass of [`SocketConnection`][crate::SocketConnection] that is created
    /// for TCP/IP sockets.
    ///
    /// ## Properties
    ///
    ///
    /// #### `graceful-disconnect`
    ///  Readable | Writeable
    /// <details><summary><h4>SocketConnection</h4></summary>
    ///
    ///
    /// #### `socket`
    ///  Readable | Writeable | Construct Only
    /// </details>
    /// <details><summary><h4>IOStream</h4></summary>
    ///
    ///
    /// #### `closed`
    ///  Readable
    ///
    ///
    /// #### `input-stream`
    ///  Readable
    ///
    ///
    /// #### `output-stream`
    ///  Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TcpConnectionExt`][trait@crate::prelude::TcpConnectionExt], [`SocketConnectionExt`][trait@crate::prelude::SocketConnectionExt], [`IOStreamExt`][trait@crate::prelude::IOStreamExt], [`trait@glib::ObjectExt`], [`IOStreamExtManual`][trait@crate::prelude::IOStreamExtManual]
    #[doc(alias = "GTcpConnection")]
    pub struct TcpConnection(Object<ffi::GTcpConnection, ffi::GTcpConnectionClass>) @extends SocketConnection, IOStream;

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

impl TcpConnection {
    pub const NONE: Option<&'static TcpConnection> = None;
}

/// Trait containing all [`struct@TcpConnection`] methods.
///
/// # Implementors
///
/// [`TcpConnection`][struct@crate::TcpConnection]
pub trait TcpConnectionExt: 'static {
    /// Checks if graceful disconnects are used. See
    /// [`set_graceful_disconnect()`][Self::set_graceful_disconnect()].
    ///
    /// # Returns
    ///
    /// [`true`] if graceful disconnect is used on close, [`false`] otherwise
    #[doc(alias = "g_tcp_connection_get_graceful_disconnect")]
    #[doc(alias = "get_graceful_disconnect")]
    fn is_graceful_disconnect(&self) -> bool;

    /// This enables graceful disconnects on close. A graceful disconnect
    /// means that we signal the receiving end that the connection is terminated
    /// and wait for it to close the connection before closing the connection.
    ///
    /// A graceful disconnect means that we can be sure that we successfully sent
    /// all the outstanding data to the other end, or get an error reported.
    /// However, it also means we have to wait for all the data to reach the
    /// other side and for it to acknowledge this by closing the socket, which may
    /// take a while. For this reason it is disabled by default.
    /// ## `graceful_disconnect`
    /// Whether to do graceful disconnects or not
    #[doc(alias = "g_tcp_connection_set_graceful_disconnect")]
    fn set_graceful_disconnect(&self, graceful_disconnect: bool);

    #[doc(alias = "graceful-disconnect")]
    fn connect_graceful_disconnect_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<TcpConnection>> TcpConnectionExt for O {
    fn is_graceful_disconnect(&self) -> bool {
        unsafe {
            from_glib(ffi::g_tcp_connection_get_graceful_disconnect(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_graceful_disconnect(&self, graceful_disconnect: bool) {
        unsafe {
            ffi::g_tcp_connection_set_graceful_disconnect(
                self.as_ref().to_glib_none().0,
                graceful_disconnect.into_glib(),
            );
        }
    }

    fn connect_graceful_disconnect_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_graceful_disconnect_trampoline<
            P: IsA<TcpConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GTcpConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TcpConnection::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::graceful-disconnect\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_graceful_disconnect_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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