gi-gio-2.0.32: Gio bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | Safe-Inferred
Language | Haskell2010

GI.Gio.Interfaces.SocketConnectable

Contents

- Exported types
- Methods
  - enumerate
  - proxyEnumerate
  - toString

Description

Objects that describe one or more potential socket endpoints implement `GSocketConnectable`. Callers can then use `socketConnectableEnumerate` to get a `SocketAddressEnumerator` to try out each socket address in turn until one succeeds, as shown in the sample code below.

### c code

    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;
        }
    }

Synopsis

- newtype SocketConnectable = SocketConnectable (ManagedPtr SocketConnectable)
- class (GObject o, IsDescendantOf SocketConnectable o) => IsSocketConnectable o
- toSocketConnectable :: (MonadIO m, IsSocketConnectable o) => o -> m SocketConnectable
- socketConnectableEnumerate :: (HasCallStack, MonadIO m, IsSocketConnectable a) => a -> m SocketAddressEnumerator
- socketConnectableProxyEnumerate :: (HasCallStack, MonadIO m, IsSocketConnectable a) => a -> m SocketAddressEnumerator
- socketConnectableToString :: (HasCallStack, MonadIO m, IsSocketConnectable a) => a -> m Text

# Exported types

newtype SocketConnectable Source #

Memory-managed wrapper type.

Constructors

SocketConnectable (ManagedPtr SocketConnectable) |

#### Instances

Instances details

Eq SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable Methods (==) :: SocketConnectable -> SocketConnectable -> Bool Source # (/=) :: SocketConnectable -> SocketConnectable -> Bool Source #
GObject SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable
ManagedPtrNewtype SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable Methods toManagedPtr :: SocketConnectable -> ManagedPtr SocketConnectable Source #
TypedObject SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable Methods glibType :: IO GType Source #
HasParentTypes SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable
IsGValue (Maybe SocketConnectable) Source # | Convert `SocketConnectable` to and from `GValue`. See `toGValue` and `fromGValue`.
Instance details Defined in GI.Gio.Interfaces.SocketConnectable Methods gvalueGType_ :: IO GType Source # gvalueSet_ :: Ptr GValue -> Maybe SocketConnectable -> IO () Source # gvalueGet_ :: Ptr GValue -> IO (Maybe SocketConnectable) Source #
type ParentTypes SocketConnectable Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable type ParentTypes SocketConnectable = '[Object]

class (GObject o, IsDescendantOf SocketConnectable o) => IsSocketConnectable o Source #

Type class for types which can be safely cast to `SocketConnectable`, for instance with `toSocketConnectable`.

#### Instances

Instances details

(GObject o, IsDescendantOf SocketConnectable o) => IsSocketConnectable o Source # |
Instance details Defined in GI.Gio.Interfaces.SocketConnectable

toSocketConnectable :: (MonadIO m, IsSocketConnectable o) => o -> m SocketConnectable Source #

Cast to `SocketConnectable`, for types for which this is known to be safe. For general casts, use `castTo`.

# Methods

### Click to display all available methods, including inherited ones

Expand

#### Methods

bindProperty, bindPropertyFull, enumerate, forceFloating, freezeNotify, getv, isFloating, notify, notifyByPspec, proxyEnumerate, ref, refSink, runDispose, stealData, stealQdata, thawNotify, toString, unref, watchClosure.

#### Getters

getData, getProperty, getQdata.

#### Setters

setData, setDataFull, setProperty.

## enumerate

socketConnectableEnumerate Source #

Arguments

:: (HasCallStack, MonadIO m, IsSocketConnectable a) |
=> a | `connectable`: a `SocketConnectable`
-> m SocketAddressEnumerator | Returns: a new `SocketAddressEnumerator`.

Creates a `SocketAddressEnumerator` for `connectable`.

Since: 2.22

## proxyEnumerate

socketConnectableProxyEnumerate Source #

Arguments

:: (HasCallStack, MonadIO m, IsSocketConnectable a) |
=> a | `connectable`: a `SocketConnectable`
-> m SocketAddressEnumerator | Returns: a new `SocketAddressEnumerator`.

Creates a `SocketAddressEnumerator` for `connectable` that will return a `ProxyAddress` for each of its addresses that you must connect to via a proxy.

If `connectable` does not implement `socketConnectableProxyEnumerate`, this will fall back to calling `socketConnectableEnumerate`.

Since: 2.26

## toString

socketConnectableToString Source #

Arguments

:: (HasCallStack, MonadIO m, IsSocketConnectable a) |
=> a | `connectable`: a `SocketConnectable`
-> m Text | Returns: the formatted string

Format a `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` implementation does not support string formatting, the implementation’s type name will be returned as a fallback.

Since: 2.48