// 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::Cancellable;
use crate::Credentials;
use crate::InetAddress;
use crate::SocketAddress;
use crate::SocketConnection;
use crate::SocketFamily;
use crate::SocketProtocol;
use crate::SocketType;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::ObjectExt;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;
use std::ptr;

glib::wrapper! {
    /// A [`Socket`][crate::Socket] is a low-level networking primitive. It is a more or less
    /// direct mapping of the BSD socket API in a portable GObject based API.
    /// It supports both the UNIX socket implementations and winsock2 on Windows.
    ///
    /// [`Socket`][crate::Socket] is the platform independent base upon which the higher level
    /// network primitives are based. Applications are not typically meant to
    /// use it directly, but rather through classes like [`SocketClient`][crate::SocketClient],
    /// [`SocketService`][crate::SocketService] and [`SocketConnection`][crate::SocketConnection]. However there may be cases where
    /// direct use of [`Socket`][crate::Socket] is useful.
    ///
    /// [`Socket`][crate::Socket] implements the `GInitable` interface, so if it is manually constructed
    /// by e.g. [`glib::Object::new()`][crate::glib::Object::new()] you must call `g_initable_init()` and check the
    /// results before using the object. This is done automatically in
    /// [`new()`][Self::new()] and [`from_fd()`][Self::from_fd()], so these functions can return
    /// [`None`].
    ///
    /// Sockets operate in two general modes, blocking or non-blocking. When
    /// in blocking mode all operations (which don’t take an explicit blocking
    /// parameter) block until the requested operation
    /// is finished or there is an error. In non-blocking mode all calls that
    /// would block return immediately with a [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error.
    /// To know when a call would successfully run you can call [`SocketExt::condition_check()`][crate::prelude::SocketExt::condition_check()],
    /// or [`SocketExt::condition_wait()`][crate::prelude::SocketExt::condition_wait()]. You can also use `g_socket_create_source()` and
    /// attach it to a [`glib::MainContext`][crate::glib::MainContext] to get callbacks when I/O is possible.
    /// Note that all sockets are always set to non blocking mode in the system, and
    /// blocking mode is emulated in GSocket.
    ///
    /// When working in non-blocking mode applications should always be able to
    /// handle getting a [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error even when some other
    /// function said that I/O was possible. This can easily happen in case
    /// of a race condition in the application, but it can also happen for other
    /// reasons. For instance, on Windows a socket is always seen as writable
    /// until a write returns [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
    ///
    /// `GSockets` can be either connection oriented or datagram based.
    /// For connection oriented types you must first establish a connection by
    /// either connecting to an address or accepting a connection from another
    /// address. For connectionless socket types the target/source address is
    /// specified or received in each I/O operation.
    ///
    /// All socket file descriptors are set to be close-on-exec.
    ///
    /// Note that creating a [`Socket`][crate::Socket] causes the signal `SIGPIPE` to be
    /// ignored for the remainder of the program. If you are writing a
    /// command-line utility that uses [`Socket`][crate::Socket], you may need to take into
    /// account the fact that your program will not automatically be killed
    /// if it tries to write to `stdout` after it has been closed.
    ///
    /// Like most other APIs in GLib, [`Socket`][crate::Socket] is not inherently thread safe. To use
    /// a [`Socket`][crate::Socket] concurrently from multiple threads, you must implement your own
    /// locking.
    ///
    /// # Implements
    ///
    /// [`SocketExt`][trait@crate::prelude::SocketExt], [`trait@glib::ObjectExt`], [`SocketExtManual`][trait@crate::prelude::SocketExtManual]
    #[doc(alias = "GSocket")]
    pub struct Socket(Object<ffi::GSocket, ffi::GSocketClass>);

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

impl Socket {
    /// Creates a new [`Socket`][crate::Socket] with the defined family, type and protocol.
    /// If `protocol` is 0 ([`SocketProtocol::Default`][crate::SocketProtocol::Default]) the default protocol type
    /// for the family and type is used.
    ///
    /// The `protocol` is a family and type specific int that specifies what
    /// kind of protocol to use. [`SocketProtocol`][crate::SocketProtocol] lists several common ones.
    /// Many families only support one protocol, and use 0 for this, others
    /// support several and using 0 means to use the default protocol for
    /// the family and type.
    ///
    /// The protocol id is passed directly to the operating
    /// system, so you can use protocols not listed in [`SocketProtocol`][crate::SocketProtocol] if you
    /// know the protocol number used for it.
    /// ## `family`
    /// the socket family to use, e.g. [`SocketFamily::Ipv4`][crate::SocketFamily::Ipv4].
    /// ## `type_`
    /// the socket type to use.
    /// ## `protocol`
    /// the id of the protocol to use, or 0 for default.
    ///
    /// # Returns
    ///
    /// a [`Socket`][crate::Socket] or [`None`] on error.
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_socket_new")]
    pub fn new(
        family: SocketFamily,
        type_: SocketType,
        protocol: SocketProtocol,
    ) -> Result<Socket, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_socket_new(
                family.into_glib(),
                type_.into_glib(),
                protocol.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

unsafe impl glib::SendUnique for Socket {
    fn is_unique(&self) -> bool {
        self.ref_count() == 1
    }
}

pub const NONE_SOCKET: Option<&Socket> = None;

/// Trait containing all [`struct@Socket`] methods.
///
/// # Implementors
///
/// [`Socket`][struct@crate::Socket]
pub trait SocketExt: 'static {
    /// Accept incoming connections on a connection-based socket. This removes
    /// the first outstanding connection request from the listening socket and
    /// creates a [`Socket`][crate::Socket] object for it.
    ///
    /// The `self` must be bound to a local address with [`bind()`][Self::bind()] and
    /// must be listening for incoming connections ([`listen()`][Self::listen()]).
    ///
    /// If there are no outstanding connections then the operation will block
    /// or return [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] if non-blocking I/O is enabled.
    /// To be notified of an incoming connection, wait for the [`glib::IOCondition::IN`][crate::glib::IOCondition::IN] condition.
    /// ## `cancellable`
    /// a `GCancellable` or [`None`]
    ///
    /// # Returns
    ///
    /// a new [`Socket`][crate::Socket], or [`None`] on error.
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_socket_accept")]
    fn accept<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<Socket, glib::Error>;

    /// When a socket is created it is attached to an address family, but it
    /// doesn't have an address in this family. [`bind()`][Self::bind()] assigns the
    /// address (sometimes called name) of the socket.
    ///
    /// It is generally required to bind to a local address before you can
    /// receive connections. (See [`listen()`][Self::listen()] and [`accept()`][Self::accept()] ).
    /// In certain situations, you may also want to bind a socket that will be
    /// used to initiate connections, though this is not normally required.
    ///
    /// If `self` is a TCP socket, then `allow_reuse` controls the setting
    /// of the `SO_REUSEADDR` socket option; normally it should be [`true`] for
    /// server sockets (sockets that you will eventually call
    /// [`accept()`][Self::accept()] on), and [`false`] for client sockets. (Failing to
    /// set this flag on a server socket may cause [`bind()`][Self::bind()] to return
    /// [`IOErrorEnum::AddressInUse`][crate::IOErrorEnum::AddressInUse] if the server program is stopped and then
    /// immediately restarted.)
    ///
    /// If `self` is a UDP socket, then `allow_reuse` determines whether or
    /// not other UDP sockets can be bound to the same address at the same
    /// time. In particular, you can have several UDP sockets bound to the
    /// same address, and they will all receive all of the multicast and
    /// broadcast packets sent to that address. (The behavior of unicast
    /// UDP packets to an address with multiple listeners is not defined.)
    /// ## `address`
    /// a [`SocketAddress`][crate::SocketAddress] specifying the local address.
    /// ## `allow_reuse`
    /// whether to allow reusing this address
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_bind")]
    fn bind<P: IsA<SocketAddress>>(
        &self,
        address: &P,
        allow_reuse: bool,
    ) -> Result<(), glib::Error>;

    /// Checks and resets the pending connect error for the socket.
    /// This is used to check for errors when [`connect()`][Self::connect()] is
    /// used in non-blocking mode.
    ///
    /// # Returns
    ///
    /// [`true`] if no error, [`false`] otherwise, setting `error` to the error
    #[doc(alias = "g_socket_check_connect_result")]
    fn check_connect_result(&self) -> Result<(), glib::Error>;

    /// Closes the socket, shutting down any active connection.
    ///
    /// Closing a socket does not wait for all outstanding I/O operations
    /// to finish, so the caller should not rely on them to be guaranteed
    /// to complete even if the close returns with no error.
    ///
    /// Once the socket is closed, all other operations will return
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. Closing a socket multiple times will not
    /// return an error.
    ///
    /// Sockets will be automatically closed when the last reference
    /// is dropped, but you might want to call this function to make sure
    /// resources are released as early as possible.
    ///
    /// Beware that due to the way that TCP works, it is possible for
    /// recently-sent data to be lost if either you close a socket while the
    /// [`glib::IOCondition::IN`][crate::glib::IOCondition::IN] condition is set, or else if the remote connection tries to
    /// send something to you after you close the socket but before it has
    /// finished reading all of the data you sent. There is no easy generic
    /// way to avoid this problem; the easiest fix is to design the network
    /// protocol such that the client will never send data "out of turn".
    /// Another solution is for the server to half-close the connection by
    /// calling [`shutdown()`][Self::shutdown()] with only the `shutdown_write` flag set,
    /// and then wait for the client to notice this and close its side of the
    /// connection, after which the server can safely call [`close()`][Self::close()].
    /// (This is what [`TcpConnection`][crate::TcpConnection] does if you call
    /// [`TcpConnectionExt::set_graceful_disconnect()`][crate::prelude::TcpConnectionExt::set_graceful_disconnect()]. But of course, this
    /// only works if the client will close its connection after the server
    /// does.)
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error
    #[doc(alias = "g_socket_close")]
    fn close(&self) -> Result<(), glib::Error>;

    /// Checks on the readiness of `self` to perform operations.
    /// The operations specified in `condition` are checked for and masked
    /// against the currently-satisfied conditions on `self`. The result
    /// is returned.
    ///
    /// Note that on Windows, it is possible for an operation to return
    /// [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] even immediately after
    /// [`condition_check()`][Self::condition_check()] has claimed that the socket is ready for
    /// writing. Rather than calling [`condition_check()`][Self::condition_check()] and then
    /// writing to the socket if it succeeds, it is generally better to
    /// simply try writing to the socket right away, and try again later if
    /// the initial attempt returns [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
    ///
    /// It is meaningless to specify [`glib::IOCondition::ERR`][crate::glib::IOCondition::ERR] or [`glib::IOCondition::HUP`][crate::glib::IOCondition::HUP] in condition;
    /// these conditions will always be set in the output if they are true.
    ///
    /// This call never blocks.
    /// ## `condition`
    /// a [`glib::IOCondition`][crate::glib::IOCondition] mask to check
    ///
    /// # Returns
    ///
    /// the [`glib::IOCondition`][crate::glib::IOCondition] mask of the current state
    #[doc(alias = "g_socket_condition_check")]
    fn condition_check(&self, condition: glib::IOCondition) -> glib::IOCondition;

    /// Waits for up to `timeout_us` microseconds for `condition` to become true
    /// on `self`. If the condition is met, [`true`] is returned.
    ///
    /// If `cancellable` is cancelled before the condition is met, or if
    /// `timeout_us` (or the socket's `property::Socket::timeout`) is reached before the
    /// condition is met, then [`false`] is returned and `error`, if non-[`None`],
    /// is set to the appropriate value ([`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] or
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut]).
    ///
    /// If you don't want a timeout, use [`condition_wait()`][Self::condition_wait()].
    /// (Alternatively, you can pass -1 for `timeout_us`.)
    ///
    /// Note that although `timeout_us` is in microseconds for consistency with
    /// other GLib APIs, this function actually only has millisecond
    /// resolution, and the behavior is undefined if `timeout_us` is not an
    /// exact number of milliseconds.
    /// ## `condition`
    /// a [`glib::IOCondition`][crate::glib::IOCondition] mask to wait for
    /// ## `timeout_us`
    /// the maximum time (in microseconds) to wait, or -1
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable], or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the condition was met, [`false`] otherwise
    #[doc(alias = "g_socket_condition_timed_wait")]
    fn condition_timed_wait<P: IsA<Cancellable>>(
        &self,
        condition: glib::IOCondition,
        timeout_us: i64,
        cancellable: Option<&P>,
    ) -> Result<(), glib::Error>;

    /// Waits for `condition` to become true on `self`. When the condition
    /// is met, [`true`] is returned.
    ///
    /// If `cancellable` is cancelled before the condition is met, or if the
    /// socket has a timeout set and it is reached before the condition is
    /// met, then [`false`] is returned and `error`, if non-[`None`], is set to
    /// the appropriate value ([`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] or
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut]).
    ///
    /// See also [`condition_timed_wait()`][Self::condition_timed_wait()].
    /// ## `condition`
    /// a [`glib::IOCondition`][crate::glib::IOCondition] mask to wait for
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable], or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the condition was met, [`false`] otherwise
    #[doc(alias = "g_socket_condition_wait")]
    fn condition_wait<P: IsA<Cancellable>>(
        &self,
        condition: glib::IOCondition,
        cancellable: Option<&P>,
    ) -> Result<(), glib::Error>;

    /// Connect the socket to the specified remote address.
    ///
    /// For connection oriented socket this generally means we attempt to make
    /// a connection to the `address`. For a connection-less socket it sets
    /// the default address for [`SocketExtManual::send()`][crate::prelude::SocketExtManual::send()] and discards all incoming datagrams
    /// from other sources.
    ///
    /// Generally connection oriented sockets can only connect once, but
    /// connection-less sockets can connect multiple times to change the
    /// default address.
    ///
    /// If the connect call needs to do network I/O it will block, unless
    /// non-blocking I/O is enabled. Then [`IOErrorEnum::Pending`][crate::IOErrorEnum::Pending] is returned
    /// and the user can be notified of the connection finishing by waiting
    /// for the G_IO_OUT condition. The result of the connection must then be
    /// checked with [`check_connect_result()`][Self::check_connect_result()].
    /// ## `address`
    /// a [`SocketAddress`][crate::SocketAddress] specifying the remote address.
    /// ## `cancellable`
    /// a `GCancellable` or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if connected, [`false`] on error.
    #[doc(alias = "g_socket_connect")]
    fn connect<P: IsA<SocketAddress>, Q: IsA<Cancellable>>(
        &self,
        address: &P,
        cancellable: Option<&Q>,
    ) -> Result<(), glib::Error>;

    /// Creates a [`SocketConnection`][crate::SocketConnection] subclass of the right type for
    /// `self`.
    ///
    /// # Returns
    ///
    /// a [`SocketConnection`][crate::SocketConnection]
    #[doc(alias = "g_socket_connection_factory_create_connection")]
    fn connection_factory_create_connection(&self) -> SocketConnection;

    /// Get the amount of data pending in the OS input buffer, without blocking.
    ///
    /// If `self` is a UDP or SCTP socket, this will return the size of
    /// just the next packet, even if additional packets are buffered after
    /// that one.
    ///
    /// Note that on Windows, this function is rather inefficient in the
    /// UDP case, and so if you know any plausible upper bound on the size
    /// of the incoming packet, it is better to just do a
    /// [`SocketExtManual::receive()`][crate::prelude::SocketExtManual::receive()] with a buffer of that size, rather than calling
    /// [`available_bytes()`][Self::available_bytes()] first and then doing a receive of
    /// exactly the right size.
    ///
    /// # Returns
    ///
    /// the number of bytes that can be read from the socket
    /// without blocking or truncating, or -1 on error.
    #[doc(alias = "g_socket_get_available_bytes")]
    #[doc(alias = "get_available_bytes")]
    fn available_bytes(&self) -> isize;

    /// Gets the blocking mode of the socket. For details on blocking I/O,
    /// see [`set_blocking()`][Self::set_blocking()].
    ///
    /// # Returns
    ///
    /// [`true`] if blocking I/O is used, [`false`] otherwise.
    #[doc(alias = "g_socket_get_blocking")]
    #[doc(alias = "get_blocking")]
    fn is_blocking(&self) -> bool;

    /// Gets the broadcast setting on `self`; if [`true`],
    /// it is possible to send packets to broadcast
    /// addresses.
    ///
    /// # Returns
    ///
    /// the broadcast setting on `self`
    #[doc(alias = "g_socket_get_broadcast")]
    #[doc(alias = "get_broadcast")]
    fn is_broadcast(&self) -> bool;

    /// Returns the credentials of the foreign process connected to this
    /// socket, if any (e.g. it is only supported for [`SocketFamily::Unix`][crate::SocketFamily::Unix]
    /// sockets).
    ///
    /// If this operation isn't supported on the OS, the method fails with
    /// the [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error. On Linux this is implemented
    /// by reading the `SO_PEERCRED` option on the underlying socket.
    ///
    /// This method can be expected to be available on the following platforms:
    ///
    /// - Linux since GLib 2.26
    /// - OpenBSD since GLib 2.30
    /// - Solaris, Illumos and OpenSolaris since GLib 2.40
    /// - NetBSD since GLib 2.42
    /// - macOS, tvOS, iOS since GLib 2.66
    ///
    /// Other ways to obtain credentials from a foreign peer includes the
    /// `GUnixCredentialsMessage` type and
    /// `g_unix_connection_send_credentials()` /
    /// `g_unix_connection_receive_credentials()` functions.
    ///
    /// # Returns
    ///
    /// [`None`] if `error` is set, otherwise a [`Credentials`][crate::Credentials] object
    /// that must be freed with `g_object_unref()`.
    #[doc(alias = "g_socket_get_credentials")]
    #[doc(alias = "get_credentials")]
    fn credentials(&self) -> Result<Credentials, glib::Error>;

    /// Gets the socket family of the socket.
    ///
    /// # Returns
    ///
    /// a [`SocketFamily`][crate::SocketFamily]
    #[doc(alias = "g_socket_get_family")]
    #[doc(alias = "get_family")]
    fn family(&self) -> SocketFamily;

    /// Gets the keepalive mode of the socket. For details on this,
    /// see [`set_keepalive()`][Self::set_keepalive()].
    ///
    /// # Returns
    ///
    /// [`true`] if keepalive is active, [`false`] otherwise.
    #[doc(alias = "g_socket_get_keepalive")]
    #[doc(alias = "get_keepalive")]
    fn is_keepalive(&self) -> bool;

    /// Gets the listen backlog setting of the socket. For details on this,
    /// see [`set_listen_backlog()`][Self::set_listen_backlog()].
    ///
    /// # Returns
    ///
    /// the maximum number of pending connections.
    #[doc(alias = "g_socket_get_listen_backlog")]
    #[doc(alias = "get_listen_backlog")]
    fn listen_backlog(&self) -> i32;

    /// Try to get the local address of a bound socket. This is only
    /// useful if the socket has been bound to a local address,
    /// either explicitly or implicitly when connecting.
    ///
    /// # Returns
    ///
    /// a [`SocketAddress`][crate::SocketAddress] or [`None`] on error.
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_socket_get_local_address")]
    #[doc(alias = "get_local_address")]
    fn local_address(&self) -> Result<SocketAddress, glib::Error>;

    /// Gets the multicast loopback setting on `self`; if [`true`] (the
    /// default), outgoing multicast packets will be looped back to
    /// multicast listeners on the same host.
    ///
    /// # Returns
    ///
    /// the multicast loopback setting on `self`
    #[doc(alias = "g_socket_get_multicast_loopback")]
    #[doc(alias = "get_multicast_loopback")]
    fn is_multicast_loopback(&self) -> bool;

    /// Gets the multicast time-to-live setting on `self`; see
    /// [`set_multicast_ttl()`][Self::set_multicast_ttl()] for more details.
    ///
    /// # Returns
    ///
    /// the multicast time-to-live setting on `self`
    #[doc(alias = "g_socket_get_multicast_ttl")]
    #[doc(alias = "get_multicast_ttl")]
    fn multicast_ttl(&self) -> u32;

    /// Gets the value of an integer-valued option on `self`, as with
    /// `getsockopt()`. (If you need to fetch a non-integer-valued option,
    /// you will need to call `getsockopt()` directly.)
    ///
    /// The [<gio/gnetworking.h>][gio-gnetworking.h]
    /// header pulls in system headers that will define most of the
    /// standard/portable socket options. For unusual socket protocols or
    /// platform-dependent options, you may need to include additional
    /// headers.
    ///
    /// Note that even for socket options that are a single byte in size,
    /// `value` is still a pointer to a `gint` variable, not a `guchar`;
    /// [`option()`][Self::option()] will handle the conversion internally.
    /// ## `level`
    /// the "API level" of the option (eg, `SOL_SOCKET`)
    /// ## `optname`
    /// the "name" of the option (eg, `SO_BROADCAST`)
    ///
    /// # Returns
    ///
    /// success or failure. On failure, `error` will be set, and
    ///  the system error value (`errno` or WSAGetLastError()) will still
    ///  be set to the result of the `getsockopt()` call.
    ///
    /// ## `value`
    /// return location for the option value
    #[doc(alias = "g_socket_get_option")]
    #[doc(alias = "get_option")]
    fn option(&self, level: i32, optname: i32) -> Result<i32, glib::Error>;

    /// Gets the socket protocol id the socket was created with.
    /// In case the protocol is unknown, -1 is returned.
    ///
    /// # Returns
    ///
    /// a protocol id, or -1 if unknown
    #[doc(alias = "g_socket_get_protocol")]
    #[doc(alias = "get_protocol")]
    fn protocol(&self) -> SocketProtocol;

    /// Try to get the remote address of a connected socket. This is only
    /// useful for connection oriented sockets that have been connected.
    ///
    /// # Returns
    ///
    /// a [`SocketAddress`][crate::SocketAddress] or [`None`] on error.
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_socket_get_remote_address")]
    #[doc(alias = "get_remote_address")]
    fn remote_address(&self) -> Result<SocketAddress, glib::Error>;

    /// Gets the socket type of the socket.
    ///
    /// # Returns
    ///
    /// a [`SocketType`][crate::SocketType]
    #[doc(alias = "g_socket_get_socket_type")]
    #[doc(alias = "get_socket_type")]
    fn socket_type(&self) -> SocketType;

    /// Gets the timeout setting of the socket. For details on this, see
    /// [`set_timeout()`][Self::set_timeout()].
    ///
    /// # Returns
    ///
    /// the timeout in seconds
    #[doc(alias = "g_socket_get_timeout")]
    #[doc(alias = "get_timeout")]
    fn timeout(&self) -> u32;

    /// Gets the unicast time-to-live setting on `self`; see
    /// [`set_ttl()`][Self::set_ttl()] for more details.
    ///
    /// # Returns
    ///
    /// the time-to-live setting on `self`
    #[doc(alias = "g_socket_get_ttl")]
    #[doc(alias = "get_ttl")]
    fn ttl(&self) -> u32;

    /// Checks whether a socket is closed.
    ///
    /// # Returns
    ///
    /// [`true`] if socket is closed, [`false`] otherwise
    #[doc(alias = "g_socket_is_closed")]
    fn is_closed(&self) -> bool;

    /// Check whether the socket is connected. This is only useful for
    /// connection-oriented sockets.
    ///
    /// If using [`shutdown()`][Self::shutdown()], this function will return [`true`] until the
    /// socket has been shut down for reading and writing. If you do a non-blocking
    /// connect, this function will not return [`true`] until after you call
    /// [`check_connect_result()`][Self::check_connect_result()].
    ///
    /// # Returns
    ///
    /// [`true`] if socket is connected, [`false`] otherwise.
    #[doc(alias = "g_socket_is_connected")]
    fn is_connected(&self) -> bool;

    /// Registers `self` to receive multicast messages sent to `group`.
    /// `self` must be a [`SocketType::Datagram`][crate::SocketType::Datagram] socket, and must have
    /// been bound to an appropriate interface and port with
    /// [`bind()`][Self::bind()].
    ///
    /// If `iface` is [`None`], the system will automatically pick an interface
    /// to bind to based on `group`.
    ///
    /// If `source_specific` is [`true`], source-specific multicast as defined
    /// in RFC 4604 is used. Note that on older platforms this may fail
    /// with a [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error.
    ///
    /// To bind to a given source-specific multicast address, use
    /// [`join_multicast_group_ssm()`][Self::join_multicast_group_ssm()] instead.
    /// ## `group`
    /// a [`InetAddress`][crate::InetAddress] specifying the group address to join.
    /// ## `source_specific`
    /// [`true`] if source-specific multicast should be used
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_join_multicast_group")]
    fn join_multicast_group<P: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error>;

    /// Registers `self` to receive multicast messages sent to `group`.
    /// `self` must be a [`SocketType::Datagram`][crate::SocketType::Datagram] socket, and must have
    /// been bound to an appropriate interface and port with
    /// [`bind()`][Self::bind()].
    ///
    /// If `iface` is [`None`], the system will automatically pick an interface
    /// to bind to based on `group`.
    ///
    /// If `source_specific` is not [`None`], use source-specific multicast as
    /// defined in RFC 4604. Note that on older platforms this may fail
    /// with a [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error.
    ///
    /// Note that this function can be called multiple times for the same
    /// `group` with different `source_specific` in order to receive multicast
    /// packets from more than one source.
    /// ## `group`
    /// a [`InetAddress`][crate::InetAddress] specifying the group address to join.
    /// ## `source_specific`
    /// a [`InetAddress`][crate::InetAddress] specifying the
    /// source-specific multicast address or [`None`] to ignore.
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[cfg(any(feature = "v2_56", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_56")))]
    #[doc(alias = "g_socket_join_multicast_group_ssm")]
    fn join_multicast_group_ssm<P: IsA<InetAddress>, Q: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: Option<&Q>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error>;

    /// Removes `self` from the multicast group defined by `group`, `iface`,
    /// and `source_specific` (which must all have the same values they had
    /// when you joined the group).
    ///
    /// `self` remains bound to its address and port, and can still receive
    /// unicast messages after calling this.
    ///
    /// To unbind to a given source-specific multicast address, use
    /// [`leave_multicast_group_ssm()`][Self::leave_multicast_group_ssm()] instead.
    /// ## `group`
    /// a [`InetAddress`][crate::InetAddress] specifying the group address to leave.
    /// ## `source_specific`
    /// [`true`] if source-specific multicast was used
    /// ## `iface`
    /// Interface used
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_leave_multicast_group")]
    fn leave_multicast_group<P: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error>;

    /// Removes `self` from the multicast group defined by `group`, `iface`,
    /// and `source_specific` (which must all have the same values they had
    /// when you joined the group).
    ///
    /// `self` remains bound to its address and port, and can still receive
    /// unicast messages after calling this.
    /// ## `group`
    /// a [`InetAddress`][crate::InetAddress] specifying the group address to leave.
    /// ## `source_specific`
    /// a [`InetAddress`][crate::InetAddress] specifying the
    /// source-specific multicast address or [`None`] to ignore.
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[cfg(any(feature = "v2_56", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_56")))]
    #[doc(alias = "g_socket_leave_multicast_group_ssm")]
    fn leave_multicast_group_ssm<P: IsA<InetAddress>, Q: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: Option<&Q>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error>;

    /// Marks the socket as a server socket, i.e. a socket that is used
    /// to accept incoming requests using [`accept()`][Self::accept()].
    ///
    /// Before calling this the socket must be bound to a local address using
    /// [`bind()`][Self::bind()].
    ///
    /// To set the maximum amount of outstanding clients, use
    /// [`set_listen_backlog()`][Self::set_listen_backlog()].
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_listen")]
    fn listen(&self) -> Result<(), glib::Error>;

    /// Sets the blocking mode of the socket. In blocking mode
    /// all operations (which don’t take an explicit blocking parameter) block until
    /// they succeed or there is an error. In
    /// non-blocking mode all functions return results immediately or
    /// with a [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error.
    ///
    /// All sockets are created in blocking mode. However, note that the
    /// platform level socket is always non-blocking, and blocking mode
    /// is a GSocket level feature.
    /// ## `blocking`
    /// Whether to use blocking I/O or not.
    #[doc(alias = "g_socket_set_blocking")]
    fn set_blocking(&self, blocking: bool);

    /// Sets whether `self` should allow sending to broadcast addresses.
    /// This is [`false`] by default.
    /// ## `broadcast`
    /// whether `self` should allow sending to broadcast
    ///  addresses
    #[doc(alias = "g_socket_set_broadcast")]
    fn set_broadcast(&self, broadcast: bool);

    /// Sets or unsets the `SO_KEEPALIVE` flag on the underlying socket. When
    /// this flag is set on a socket, the system will attempt to verify that the
    /// remote socket endpoint is still present if a sufficiently long period of
    /// time passes with no data being exchanged. If the system is unable to
    /// verify the presence of the remote endpoint, it will automatically close
    /// the connection.
    ///
    /// This option is only functional on certain kinds of sockets. (Notably,
    /// [`SocketProtocol::Tcp`][crate::SocketProtocol::Tcp] sockets.)
    ///
    /// The exact time between pings is system- and protocol-dependent, but will
    /// normally be at least two hours. Most commonly, you would set this flag
    /// on a server socket if you want to allow clients to remain idle for long
    /// periods of time, but also want to ensure that connections are eventually
    /// garbage-collected if clients crash or become unreachable.
    /// ## `keepalive`
    /// Value for the keepalive flag
    #[doc(alias = "g_socket_set_keepalive")]
    fn set_keepalive(&self, keepalive: bool);

    /// Sets the maximum number of outstanding connections allowed
    /// when listening on this socket. If more clients than this are
    /// connecting to the socket and the application is not handling them
    /// on time then the new connections will be refused.
    ///
    /// Note that this must be called before [`listen()`][Self::listen()] and has no
    /// effect if called after that.
    /// ## `backlog`
    /// the maximum number of pending connections.
    #[doc(alias = "g_socket_set_listen_backlog")]
    fn set_listen_backlog(&self, backlog: i32);

    /// Sets whether outgoing multicast packets will be received by sockets
    /// listening on that multicast address on the same host. This is [`true`]
    /// by default.
    /// ## `loopback`
    /// whether `self` should receive messages sent to its
    ///  multicast groups from the local host
    #[doc(alias = "g_socket_set_multicast_loopback")]
    fn set_multicast_loopback(&self, loopback: bool);

    /// Sets the time-to-live for outgoing multicast datagrams on `self`.
    /// By default, this is 1, meaning that multicast packets will not leave
    /// the local network.
    /// ## `ttl`
    /// the time-to-live value for all multicast datagrams on `self`
    #[doc(alias = "g_socket_set_multicast_ttl")]
    fn set_multicast_ttl(&self, ttl: u32);

    /// Sets the value of an integer-valued option on `self`, as with
    /// `setsockopt()`. (If you need to set a non-integer-valued option,
    /// you will need to call `setsockopt()` directly.)
    ///
    /// The [<gio/gnetworking.h>][gio-gnetworking.h]
    /// header pulls in system headers that will define most of the
    /// standard/portable socket options. For unusual socket protocols or
    /// platform-dependent options, you may need to include additional
    /// headers.
    /// ## `level`
    /// the "API level" of the option (eg, `SOL_SOCKET`)
    /// ## `optname`
    /// the "name" of the option (eg, `SO_BROADCAST`)
    /// ## `value`
    /// the value to set the option to
    ///
    /// # Returns
    ///
    /// success or failure. On failure, `error` will be set, and
    ///  the system error value (`errno` or WSAGetLastError()) will still
    ///  be set to the result of the `setsockopt()` call.
    #[doc(alias = "g_socket_set_option")]
    fn set_option(&self, level: i32, optname: i32, value: i32) -> Result<(), glib::Error>;

    /// Sets the time in seconds after which I/O operations on `self` will
    /// time out if they have not yet completed.
    ///
    /// On a blocking socket, this means that any blocking [`Socket`][crate::Socket]
    /// operation will time out after `timeout` seconds of inactivity,
    /// returning [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut].
    ///
    /// On a non-blocking socket, calls to [`condition_wait()`][Self::condition_wait()] will
    /// also fail with [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut] after the given time. Sources
    /// created with `g_socket_create_source()` will trigger after
    /// `timeout` seconds of inactivity, with the requested condition
    /// set, at which point calling [`SocketExtManual::receive()`][crate::prelude::SocketExtManual::receive()], [`SocketExtManual::send()`][crate::prelude::SocketExtManual::send()],
    /// [`check_connect_result()`][Self::check_connect_result()], etc, will fail with
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut].
    ///
    /// If `timeout` is 0 (the default), operations will never time out
    /// on their own.
    ///
    /// Note that if an I/O operation is interrupted by a signal, this may
    /// cause the timeout to be reset.
    /// ## `timeout`
    /// the timeout for `self`, in seconds, or 0 for none
    #[doc(alias = "g_socket_set_timeout")]
    fn set_timeout(&self, timeout: u32);

    /// Sets the time-to-live for outgoing unicast packets on `self`.
    /// By default the platform-specific default value is used.
    /// ## `ttl`
    /// the time-to-live value for all unicast packets on `self`
    #[doc(alias = "g_socket_set_ttl")]
    fn set_ttl(&self, ttl: u32);

    /// Shut down part or all of a full-duplex connection.
    ///
    /// If `shutdown_read` is [`true`] then the receiving side of the connection
    /// is shut down, and further reading is disallowed.
    ///
    /// If `shutdown_write` is [`true`] then the sending side of the connection
    /// is shut down, and further writing is disallowed.
    ///
    /// It is allowed for both `shutdown_read` and `shutdown_write` to be [`true`].
    ///
    /// One example where it is useful to shut down only one side of a connection is
    /// graceful disconnect for TCP connections where you close the sending side,
    /// then wait for the other side to close the connection, thus ensuring that the
    /// other side saw all sent data.
    /// ## `shutdown_read`
    /// whether to shut down the read side
    /// ## `shutdown_write`
    /// whether to shut down the write side
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error
    #[doc(alias = "g_socket_shutdown")]
    fn shutdown(&self, shutdown_read: bool, shutdown_write: bool) -> Result<(), glib::Error>;

    /// Checks if a socket is capable of speaking IPv4.
    ///
    /// IPv4 sockets are capable of speaking IPv4. On some operating systems
    /// and under some combinations of circumstances IPv6 sockets are also
    /// capable of speaking IPv4. See RFC 3493 section 3.7 for more
    /// information.
    ///
    /// No other types of sockets are currently considered as being capable
    /// of speaking IPv4.
    ///
    /// # Returns
    ///
    /// [`true`] if this socket can be used with IPv4.
    #[doc(alias = "g_socket_speaks_ipv4")]
    fn speaks_ipv4(&self) -> bool;

    #[doc(alias = "type")]
    fn type_(&self) -> SocketType;

    #[doc(alias = "blocking")]
    fn connect_blocking_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "broadcast")]
    fn connect_broadcast_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "keepalive")]
    fn connect_keepalive_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "listen-backlog")]
    fn connect_listen_backlog_notify<F: Fn(&Self) + Send + 'static>(&self, f: F)
        -> SignalHandlerId;

    #[doc(alias = "local-address")]
    fn connect_local_address_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "multicast-loopback")]
    fn connect_multicast_loopback_notify<F: Fn(&Self) + Send + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "multicast-ttl")]
    fn connect_multicast_ttl_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "remote-address")]
    fn connect_remote_address_notify<F: Fn(&Self) + Send + 'static>(&self, f: F)
        -> SignalHandlerId;

    #[doc(alias = "timeout")]
    fn connect_timeout_notify<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;

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

impl<O: IsA<Socket>> SocketExt for O {
    fn accept<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> Result<Socket, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_socket_accept(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn bind<P: IsA<SocketAddress>>(
        &self,
        address: &P,
        allow_reuse: bool,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_bind(
                self.as_ref().to_glib_none().0,
                address.as_ref().to_glib_none().0,
                allow_reuse.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn check_connect_result(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_check_connect_result(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn close(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_close(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn condition_check(&self, condition: glib::IOCondition) -> glib::IOCondition {
        unsafe {
            from_glib(ffi::g_socket_condition_check(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
            ))
        }
    }

    fn condition_timed_wait<P: IsA<Cancellable>>(
        &self,
        condition: glib::IOCondition,
        timeout_us: i64,
        cancellable: Option<&P>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_condition_timed_wait(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
                timeout_us,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn condition_wait<P: IsA<Cancellable>>(
        &self,
        condition: glib::IOCondition,
        cancellable: Option<&P>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_condition_wait(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn connect<P: IsA<SocketAddress>, Q: IsA<Cancellable>>(
        &self,
        address: &P,
        cancellable: Option<&Q>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_connect(
                self.as_ref().to_glib_none().0,
                address.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn connection_factory_create_connection(&self) -> SocketConnection {
        unsafe {
            from_glib_full(ffi::g_socket_connection_factory_create_connection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn available_bytes(&self) -> isize {
        unsafe { ffi::g_socket_get_available_bytes(self.as_ref().to_glib_none().0) }
    }

    fn is_blocking(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_blocking(self.as_ref().to_glib_none().0)) }
    }

    fn is_broadcast(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_broadcast(self.as_ref().to_glib_none().0)) }
    }

    fn credentials(&self) -> Result<Credentials, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_socket_get_credentials(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn family(&self) -> SocketFamily {
        unsafe { from_glib(ffi::g_socket_get_family(self.as_ref().to_glib_none().0)) }
    }

    fn is_keepalive(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_keepalive(self.as_ref().to_glib_none().0)) }
    }

    fn listen_backlog(&self) -> i32 {
        unsafe { ffi::g_socket_get_listen_backlog(self.as_ref().to_glib_none().0) }
    }

    fn local_address(&self) -> Result<SocketAddress, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_socket_get_local_address(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn is_multicast_loopback(&self) -> bool {
        unsafe {
            from_glib(ffi::g_socket_get_multicast_loopback(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn multicast_ttl(&self) -> u32 {
        unsafe { ffi::g_socket_get_multicast_ttl(self.as_ref().to_glib_none().0) }
    }

    fn option(&self, level: i32, optname: i32) -> Result<i32, glib::Error> {
        unsafe {
            let mut value = mem::MaybeUninit::uninit();
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_get_option(
                self.as_ref().to_glib_none().0,
                level,
                optname,
                value.as_mut_ptr(),
                &mut error,
            );
            let value = value.assume_init();
            if error.is_null() {
                Ok(value)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn protocol(&self) -> SocketProtocol {
        unsafe { from_glib(ffi::g_socket_get_protocol(self.as_ref().to_glib_none().0)) }
    }

    fn remote_address(&self) -> Result<SocketAddress, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_socket_get_remote_address(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn socket_type(&self) -> SocketType {
        unsafe {
            from_glib(ffi::g_socket_get_socket_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn timeout(&self) -> u32 {
        unsafe { ffi::g_socket_get_timeout(self.as_ref().to_glib_none().0) }
    }

    fn ttl(&self) -> u32 {
        unsafe { ffi::g_socket_get_ttl(self.as_ref().to_glib_none().0) }
    }

    fn is_closed(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_is_closed(self.as_ref().to_glib_none().0)) }
    }

    fn is_connected(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_is_connected(self.as_ref().to_glib_none().0)) }
    }

    fn join_multicast_group<P: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_join_multicast_group(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.into_glib(),
                iface.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v2_56", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_56")))]
    fn join_multicast_group_ssm<P: IsA<InetAddress>, Q: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: Option<&Q>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_join_multicast_group_ssm(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.map(|p| p.as_ref()).to_glib_none().0,
                iface.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn leave_multicast_group<P: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_leave_multicast_group(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.into_glib(),
                iface.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v2_56", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_56")))]
    fn leave_multicast_group_ssm<P: IsA<InetAddress>, Q: IsA<InetAddress>>(
        &self,
        group: &P,
        source_specific: Option<&Q>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_leave_multicast_group_ssm(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.map(|p| p.as_ref()).to_glib_none().0,
                iface.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn listen(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_listen(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_blocking(&self, blocking: bool) {
        unsafe {
            ffi::g_socket_set_blocking(self.as_ref().to_glib_none().0, blocking.into_glib());
        }
    }

    fn set_broadcast(&self, broadcast: bool) {
        unsafe {
            ffi::g_socket_set_broadcast(self.as_ref().to_glib_none().0, broadcast.into_glib());
        }
    }

    fn set_keepalive(&self, keepalive: bool) {
        unsafe {
            ffi::g_socket_set_keepalive(self.as_ref().to_glib_none().0, keepalive.into_glib());
        }
    }

    fn set_listen_backlog(&self, backlog: i32) {
        unsafe {
            ffi::g_socket_set_listen_backlog(self.as_ref().to_glib_none().0, backlog);
        }
    }

    fn set_multicast_loopback(&self, loopback: bool) {
        unsafe {
            ffi::g_socket_set_multicast_loopback(
                self.as_ref().to_glib_none().0,
                loopback.into_glib(),
            );
        }
    }

    fn set_multicast_ttl(&self, ttl: u32) {
        unsafe {
            ffi::g_socket_set_multicast_ttl(self.as_ref().to_glib_none().0, ttl);
        }
    }

    fn set_option(&self, level: i32, optname: i32, value: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_set_option(
                self.as_ref().to_glib_none().0,
                level,
                optname,
                value,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_timeout(&self, timeout: u32) {
        unsafe {
            ffi::g_socket_set_timeout(self.as_ref().to_glib_none().0, timeout);
        }
    }

    fn set_ttl(&self, ttl: u32) {
        unsafe {
            ffi::g_socket_set_ttl(self.as_ref().to_glib_none().0, ttl);
        }
    }

    fn shutdown(&self, shutdown_read: bool, shutdown_write: bool) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_socket_shutdown(
                self.as_ref().to_glib_none().0,
                shutdown_read.into_glib(),
                shutdown_write.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn speaks_ipv4(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_speaks_ipv4(self.as_ref().to_glib_none().0)) }
    }

    fn type_(&self) -> SocketType {
        unsafe {
            let mut value = glib::Value::from_type(<SocketType as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"type\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `type` getter")
        }
    }

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

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

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

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

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

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

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

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

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

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

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