// 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::SocketAddressEnumerator;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// Objects that describe one or more potential socket endpoints
    /// implement [`SocketConnectable`][crate::SocketConnectable]. Callers can then use
    /// [`SocketConnectableExt::enumerate()`][crate::prelude::SocketConnectableExt::enumerate()] to get a [`SocketAddressEnumerator`][crate::SocketAddressEnumerator]
    /// to try out each socket address in turn until one succeeds, as shown
    /// in the sample code below.
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// MyConnectionType *
    /// connect_to_host (const char    *hostname,
    ///                  guint16        port,
    ///                  GCancellable  *cancellable,
    ///                  GError       **error)
    /// {
    ///   MyConnection *conn = NULL;
    ///   GSocketConnectable *addr;
    ///   GSocketAddressEnumerator *enumerator;
    ///   GSocketAddress *sockaddr;
    ///   GError *conn_error = NULL;
    ///
    ///   addr = g_network_address_new (hostname, port);
    ///   enumerator = g_socket_connectable_enumerate (addr);
    ///   g_object_unref (addr);
    ///
    ///   // Try each sockaddr until we succeed. Record the first connection error,
    ///   // but not any further ones (since they'll probably be basically the same
    ///   // as the first).
    ///   while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error))
    ///     {
    ///       conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error);
    ///       g_object_unref (sockaddr);
    ///     }
    ///   g_object_unref (enumerator);
    ///
    ///   if (conn)
    ///     {
    ///       if (conn_error)
    ///         {
    ///           // We couldn't connect to the first address, but we succeeded
    ///           // in connecting to a later address.
    ///           g_error_free (conn_error);
    ///         }
    ///       return conn;
    ///     }
    ///   else if (error)
    ///     {
    ///       /// Either initial lookup failed, or else the caller cancelled us.
    ///       if (conn_error)
    ///         g_error_free (conn_error);
    ///       return NULL;
    ///     }
    ///   else
    ///     {
    ///       g_error_propagate (error, conn_error);
    ///       return NULL;
    ///     }
    /// }
    /// ```
    ///
    /// # Implements
    ///
    /// [`SocketConnectableExt`][trait@crate::prelude::SocketConnectableExt]
    #[doc(alias = "GSocketConnectable")]
    pub struct SocketConnectable(Interface<ffi::GSocketConnectable, ffi::GSocketConnectableIface>);

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

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

/// Trait containing all [`struct@SocketConnectable`] methods.
///
/// # Implementors
///
/// [`InetSocketAddress`][struct@crate::InetSocketAddress], [`NetworkAddress`][struct@crate::NetworkAddress], [`NetworkService`][struct@crate::NetworkService], [`ProxyAddress`][struct@crate::ProxyAddress], [`SocketAddress`][struct@crate::SocketAddress], [`SocketConnectable`][struct@crate::SocketConnectable], [`UnixSocketAddress`][struct@crate::UnixSocketAddress]
pub trait SocketConnectableExt: 'static {
    /// Creates a [`SocketAddressEnumerator`][crate::SocketAddressEnumerator] for `self`.
    ///
    /// # Returns
    ///
    /// a new [`SocketAddressEnumerator`][crate::SocketAddressEnumerator].
    #[doc(alias = "g_socket_connectable_enumerate")]
    fn enumerate(&self) -> SocketAddressEnumerator;

    /// Creates a [`SocketAddressEnumerator`][crate::SocketAddressEnumerator] for `self` that will
    /// return a [`ProxyAddress`][crate::ProxyAddress] for each of its addresses that you must connect
    /// to via a proxy.
    ///
    /// If `self` does not implement
    /// [`proxy_enumerate()`][Self::proxy_enumerate()], this will fall back to
    /// calling [`enumerate()`][Self::enumerate()].
    ///
    /// # Returns
    ///
    /// a new [`SocketAddressEnumerator`][crate::SocketAddressEnumerator].
    #[doc(alias = "g_socket_connectable_proxy_enumerate")]
    fn proxy_enumerate(&self) -> SocketAddressEnumerator;

    /// Format a [`SocketConnectable`][crate::SocketConnectable] as a string. This is a human-readable format for
    /// use in debugging output, and is not a stable serialization format. It is not
    /// suitable for use in user interfaces as it exposes too much information for a
    /// user.
    ///
    /// If the [`SocketConnectable`][crate::SocketConnectable] implementation does not support string formatting,
    /// the implementation’s type name will be returned as a fallback.
    ///
    /// # Returns
    ///
    /// the formatted string
    #[doc(alias = "g_socket_connectable_to_string")]
    fn to_string(&self) -> glib::GString;
}

impl<O: IsA<SocketConnectable>> SocketConnectableExt for O {
    fn enumerate(&self) -> SocketAddressEnumerator {
        unsafe {
            from_glib_full(ffi::g_socket_connectable_enumerate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn proxy_enumerate(&self) -> SocketAddressEnumerator {
        unsafe {
            from_glib_full(ffi::g_socket_connectable_proxy_enumerate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn to_string(&self) -> glib::GString {
        unsafe {
            from_glib_full(ffi::g_socket_connectable_to_string(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

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