GI.Soup.Objects.Address

Exported types

newtype Address

Constructors

Address (ManagedPtr Address)

Instances

GObject Address

Methods

gobjectType :: Address -> IO GType

IsSocketConnectable Address

IsObject Address

IsAddress Address

((~) * info (ResolveAddressMethod t Address), MethodInfo * info Address p) => IsLabel t (Address -> p)

Methods

fromLabel :: Proxy# Symbol t -> Address -> p

((~) * info (ResolveAddressMethod t Address), MethodInfo * info Address p) => IsLabelProxy t (Address -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Address -> p

HasAttributeList * Address

type AttributeList Address

type AttributeList Address

type SignalList Address

type SignalList Address

class GObject o => IsAddress o

Instances

(GObject a, UnknownAncestorError Constraint Address a) => IsAddress a

IsAddress Address

toAddress :: IsAddress o => o -> IO Address

noAddress :: Maybe Address

Methods

equalByIp

data AddressEqualByIpMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => MethodInfo * AddressEqualByIpMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressEqualByIpMethodInfo a -> signature -> s

addressEqualByIp

Arguments

:: (HasCallStack, MonadIO m, IsAddress a, IsAddress b)

=> a

addr1: a Address with a resolved IP address

-> b

addr2: another Address with a resolved IP address

-> m Bool

Returns: whether or not addr1 and addr2 have the same IP address.

Tests if addr1 and addr2 have the same IP address. This method can be used with addressHashByIp to create a HashTable that hashes on IP address.

This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered the same. Eg, if "www.example.com" and "www.example.net" have the same IP address, then a single connection can be used to talk to either of them.

See also addressEqualByName, which compares by name rather than by IP address.

Since: 2.26

equalByName

data AddressEqualByNameMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => MethodInfo * AddressEqualByNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressEqualByNameMethodInfo a -> signature -> s

addressEqualByName

Arguments

:: (HasCallStack, MonadIO m, IsAddress a, IsAddress b)

=> a

addr1: a Address with a resolved name

-> b

addr2: another Address with a resolved name

-> m Bool

Returns: whether or not addr1 and addr2 have the same name

Tests if addr1 and addr2 have the same "name". This method can be used with addressHashByName to create a HashTable that hashes on address "names".

Comparing by name normally means comparing the addresses by their hostnames. But if the address was originally created using an IP address literal, then it will be compared by that instead.

In particular, if "www.example.com" has the IP address 10.0.0.1, and addr1 was created with the name "www.example.com" and addr2 was created with the name "10.0.0.1", then they will compare as unequal for purposes of addressEqualByName.

This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered different. Eg, for purposes of HTTP authentication or cookies, two hosts with the same IP address but different names are considered to be different hosts.

See also addressEqualByIp, which compares by IP address rather than by name.

Since: 2.26

getGsockaddr

data AddressGetGsockaddrMethodInfo

Instances

((~) * signature (m SocketAddress), MonadIO m, IsAddress a) => MethodInfo * AddressGetGsockaddrMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressGetGsockaddrMethodInfo a -> signature -> s

addressGetGsockaddr

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m SocketAddress

Returns: a new SocketAddress

Creates a new SocketAddress corresponding to addr (which is assumed to only have one socket address associated with it).

Since: 2.32

getName

data AddressGetNameMethodInfo

Instances

((~) * signature (m (Maybe Text)), MonadIO m, IsAddress a) => MethodInfo * AddressGetNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressGetNameMethodInfo a -> signature -> s

addressGetName

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m (Maybe Text)

Returns: the hostname, or Nothing if it is not known.

Returns the hostname associated with addr.

This method is not thread-safe; if you call it while addr is being resolved in another thread, it may return garbage. You can use addressIsResolved to safely test whether or not an address is resolved before fetching its name or address.

getPhysical

data AddressGetPhysicalMethodInfo

Instances

((~) * signature (m (Maybe Text)), MonadIO m, IsAddress a) => MethodInfo * AddressGetPhysicalMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressGetPhysicalMethodInfo a -> signature -> s

addressGetPhysical

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m (Maybe Text)

Returns: the physical address, or Nothing

Returns the physical address associated with addr as a string. (Eg, "127.0.0.1"). If the address is not yet known, returns Nothing.

This method is not thread-safe; if you call it while addr is being resolved in another thread, it may return garbage. You can use addressIsResolved to safely test whether or not an address is resolved before fetching its name or address.

getPort

data AddressGetPortMethodInfo

Instances

((~) * signature (m Word32), MonadIO m, IsAddress a) => MethodInfo * AddressGetPortMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressGetPortMethodInfo a -> signature -> s

addressGetPort

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m Word32

Returns: the port

Returns the port associated with addr.

hashByIp

data AddressHashByIpMethodInfo

Instances

((~) * signature (m Word32), MonadIO m, IsAddress a) => MethodInfo * AddressHashByIpMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressHashByIpMethodInfo a -> signature -> s

addressHashByIp

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m Word32

Returns: the IP-based hash value for addr.

A hash function (for HashTable) that corresponds to addressEqualByIp, qv

Since: 2.26

hashByName

data AddressHashByNameMethodInfo

Instances

((~) * signature (m Word32), MonadIO m, IsAddress a) => MethodInfo * AddressHashByNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressHashByNameMethodInfo a -> signature -> s

addressHashByName

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m Word32

Returns: the named-based hash value for addr.

A hash function (for HashTable) that corresponds to addressEqualByName, qv

Since: 2.26

isResolved

data AddressIsResolvedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsAddress a) => MethodInfo * AddressIsResolvedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressIsResolvedMethodInfo a -> signature -> s

addressIsResolved

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> a

addr: a Address

-> m Bool

Returns: True if addr has been resolved.

Tests if addr has already been resolved. Unlike the other Address "get" methods, this is safe to call when addr might be being resolved in another thread.

new

addressNew

Arguments

:: (HasCallStack, MonadIO m)

=> Text

name: a hostname or physical address

-> Word32

port: a port number

-> m Address

Returns: a Address

Creates a Address from name and port. The 'GI.Soup.Objects.Address.Address'\'s IP address may not be available right away; the caller can call addressResolveAsync or addressResolveSync to force a DNS resolution.

newAny

addressNewAny

Arguments

:: (HasCallStack, MonadIO m)

=> AddressFamily

family: the address family

-> Word32

port: the port number (usually ADDRESS_ANY_PORT)

-> m (Maybe Address)

Returns: the new Address

Returns a Address corresponding to the "any" address for family (or Nothing if family isn't supported), suitable for using as a listening Socket.

newFromSockaddr

addressNewFromSockaddr

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

sa: a pointer to a sockaddr

-> Int32

len: size of sa

-> m (Maybe Address)

Returns: the new Address

Returns a Address equivalent to sa (or Nothing if sa's address family isn't supported)

resolveAsync

data AddressResolveAsyncMethodInfo

Instances

((~) * signature (Maybe MainContext -> Maybe b -> AddressCallback -> m ()), MonadIO m, IsAddress a, IsCancellable b) => MethodInfo * AddressResolveAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressResolveAsyncMethodInfo a -> signature -> s

addressResolveAsync

Arguments

:: (HasCallStack, MonadIO m, IsAddress a, IsCancellable b)

=> a

addr: a Address

-> Maybe MainContext

asyncContext: the MainContext to call callback from

-> Maybe b

cancellable: a Cancellable object, or Nothing

-> AddressCallback

callback: callback to call with the result

-> m ()

Asynchronously resolves the missing half of addr (its IP address if it was created with addressNew, or its hostname if it was created with addressNewFromSockaddr or addressNewAny.)

If cancellable is non-Nothing, it can be used to cancel the resolution. callback will still be invoked in this case, with a status of StatusCancelled.

It is safe to call this more than once on a given address, from the same thread, with the same asyncContext (and doing so will not result in redundant DNS queries being made). But it is not safe to call from multiple threads, or with different asyncContexts, or mixed with calls to addressResolveSync.

resolveSync

data AddressResolveSyncMethodInfo

Instances

((~) * signature (Maybe b -> m Word32), MonadIO m, IsAddress a, IsCancellable b) => MethodInfo * AddressResolveSyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy AddressResolveSyncMethodInfo a -> signature -> s

addressResolveSync

Arguments

:: (HasCallStack, MonadIO m, IsAddress a, IsCancellable b)

=> a

addr: a Address

-> Maybe b

cancellable: a Cancellable object, or Nothing

-> m Word32

Returns: StatusOk, StatusCantResolve, or StatusCancelled.

Synchronously resolves the missing half of addr, as with addressResolveAsync.

If cancellable is non-Nothing, it can be used to cancel the resolution. addressResolveSync will then return a status of StatusCancelled.

It is safe to call this more than once, even from different threads, but it is not safe to mix calls to addressResolveSync with calls to addressResolveAsync on the same address.

Properties

family

data AddressFamilyPropertyInfo

Instances

AttrInfo AddressFamilyPropertyInfo

Associated Types

type AttrAllowedOps AddressFamilyPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressFamilyPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressFamilyPropertyInfo :: * -> Constraint

type AttrGetType AddressFamilyPropertyInfo :: *

type AttrLabel AddressFamilyPropertyInfo :: Symbol

type AttrOrigin AddressFamilyPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressFamilyPropertyInfo o => Proxy * AddressFamilyPropertyInfo -> o -> IO (AttrGetType AddressFamilyPropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressFamilyPropertyInfo o, AttrSetTypeConstraint AddressFamilyPropertyInfo b) => Proxy * AddressFamilyPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressFamilyPropertyInfo o => Proxy * AddressFamilyPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressFamilyPropertyInfo o, AttrSetTypeConstraint AddressFamilyPropertyInfo b) => Proxy * AddressFamilyPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressFamilyPropertyInfo

type AttrOrigin AddressFamilyPropertyInfo = Address

type AttrLabel AddressFamilyPropertyInfo

type AttrLabel AddressFamilyPropertyInfo = "family"

type AttrGetType AddressFamilyPropertyInfo

type AttrGetType AddressFamilyPropertyInfo = AddressFamily

type AttrBaseTypeConstraint AddressFamilyPropertyInfo

type AttrBaseTypeConstraint AddressFamilyPropertyInfo = IsAddress

type AttrSetTypeConstraint AddressFamilyPropertyInfo

type AttrSetTypeConstraint AddressFamilyPropertyInfo = * ~ AddressFamily

type AttrAllowedOps AddressFamilyPropertyInfo

type AttrAllowedOps AddressFamilyPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag))

addressFamily :: AttrLabelProxy "family"

constructAddressFamily :: IsAddress o => AddressFamily -> IO (GValueConstruct o)

getAddressFamily :: (MonadIO m, IsAddress o) => o -> m AddressFamily

name

data AddressNamePropertyInfo

Instances

AttrInfo AddressNamePropertyInfo

Associated Types

type AttrAllowedOps AddressNamePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressNamePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressNamePropertyInfo :: * -> Constraint

type AttrGetType AddressNamePropertyInfo :: *

type AttrLabel AddressNamePropertyInfo :: Symbol

type AttrOrigin AddressNamePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressNamePropertyInfo o => Proxy * AddressNamePropertyInfo -> o -> IO (AttrGetType AddressNamePropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressNamePropertyInfo o, AttrSetTypeConstraint AddressNamePropertyInfo b) => Proxy * AddressNamePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressNamePropertyInfo o => Proxy * AddressNamePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressNamePropertyInfo o, AttrSetTypeConstraint AddressNamePropertyInfo b) => Proxy * AddressNamePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressNamePropertyInfo

type AttrOrigin AddressNamePropertyInfo = Address

type AttrLabel AddressNamePropertyInfo

type AttrLabel AddressNamePropertyInfo = "name"

type AttrGetType AddressNamePropertyInfo

type AttrGetType AddressNamePropertyInfo = Maybe Text

type AttrBaseTypeConstraint AddressNamePropertyInfo

type AttrBaseTypeConstraint AddressNamePropertyInfo = IsAddress

type AttrSetTypeConstraint AddressNamePropertyInfo

type AttrSetTypeConstraint AddressNamePropertyInfo = * ~ Text

type AttrAllowedOps AddressNamePropertyInfo

type AttrAllowedOps AddressNamePropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag)))

addressName :: AttrLabelProxy "name"

constructAddressName :: IsAddress o => Text -> IO (GValueConstruct o)

getAddressName :: (MonadIO m, IsAddress o) => o -> m (Maybe Text)

physical

data AddressPhysicalPropertyInfo

Instances

AttrInfo AddressPhysicalPropertyInfo

Associated Types

type AttrAllowedOps AddressPhysicalPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressPhysicalPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressPhysicalPropertyInfo :: * -> Constraint

type AttrGetType AddressPhysicalPropertyInfo :: *

type AttrLabel AddressPhysicalPropertyInfo :: Symbol

type AttrOrigin AddressPhysicalPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressPhysicalPropertyInfo o => Proxy * AddressPhysicalPropertyInfo -> o -> IO (AttrGetType AddressPhysicalPropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressPhysicalPropertyInfo o, AttrSetTypeConstraint AddressPhysicalPropertyInfo b) => Proxy * AddressPhysicalPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressPhysicalPropertyInfo o => Proxy * AddressPhysicalPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressPhysicalPropertyInfo o, AttrSetTypeConstraint AddressPhysicalPropertyInfo b) => Proxy * AddressPhysicalPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressPhysicalPropertyInfo

type AttrOrigin AddressPhysicalPropertyInfo = Address

type AttrLabel AddressPhysicalPropertyInfo

type AttrLabel AddressPhysicalPropertyInfo = "physical"

type AttrGetType AddressPhysicalPropertyInfo

type AttrGetType AddressPhysicalPropertyInfo = Maybe Text

type AttrBaseTypeConstraint AddressPhysicalPropertyInfo

type AttrBaseTypeConstraint AddressPhysicalPropertyInfo = IsAddress

type AttrSetTypeConstraint AddressPhysicalPropertyInfo

type AttrSetTypeConstraint AddressPhysicalPropertyInfo = * ~ ()

type AttrAllowedOps AddressPhysicalPropertyInfo

type AttrAllowedOps AddressPhysicalPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

addressPhysical :: AttrLabelProxy "physical"

getAddressPhysical :: (MonadIO m, IsAddress o) => o -> m (Maybe Text)

port

data AddressPortPropertyInfo

Instances

AttrInfo AddressPortPropertyInfo

Associated Types

type AttrAllowedOps AddressPortPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressPortPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressPortPropertyInfo :: * -> Constraint

type AttrGetType AddressPortPropertyInfo :: *

type AttrLabel AddressPortPropertyInfo :: Symbol

type AttrOrigin AddressPortPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressPortPropertyInfo o => Proxy * AddressPortPropertyInfo -> o -> IO (AttrGetType AddressPortPropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressPortPropertyInfo o, AttrSetTypeConstraint AddressPortPropertyInfo b) => Proxy * AddressPortPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressPortPropertyInfo o => Proxy * AddressPortPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressPortPropertyInfo o, AttrSetTypeConstraint AddressPortPropertyInfo b) => Proxy * AddressPortPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressPortPropertyInfo

type AttrOrigin AddressPortPropertyInfo = Address

type AttrLabel AddressPortPropertyInfo

type AttrLabel AddressPortPropertyInfo = "port"

type AttrGetType AddressPortPropertyInfo

type AttrGetType AddressPortPropertyInfo = Int32

type AttrBaseTypeConstraint AddressPortPropertyInfo

type AttrBaseTypeConstraint AddressPortPropertyInfo = IsAddress

type AttrSetTypeConstraint AddressPortPropertyInfo

type AttrSetTypeConstraint AddressPortPropertyInfo = * ~ Int32

type AttrAllowedOps AddressPortPropertyInfo

type AttrAllowedOps AddressPortPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag))

addressPort :: AttrLabelProxy "port"

constructAddressPort :: IsAddress o => Int32 -> IO (GValueConstruct o)

getAddressPort :: (MonadIO m, IsAddress o) => o -> m Int32

protocol

data AddressProtocolPropertyInfo

Instances

AttrInfo AddressProtocolPropertyInfo

Associated Types

type AttrAllowedOps AddressProtocolPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressProtocolPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressProtocolPropertyInfo :: * -> Constraint

type AttrGetType AddressProtocolPropertyInfo :: *

type AttrLabel AddressProtocolPropertyInfo :: Symbol

type AttrOrigin AddressProtocolPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressProtocolPropertyInfo o => Proxy * AddressProtocolPropertyInfo -> o -> IO (AttrGetType AddressProtocolPropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressProtocolPropertyInfo o, AttrSetTypeConstraint AddressProtocolPropertyInfo b) => Proxy * AddressProtocolPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressProtocolPropertyInfo o => Proxy * AddressProtocolPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressProtocolPropertyInfo o, AttrSetTypeConstraint AddressProtocolPropertyInfo b) => Proxy * AddressProtocolPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressProtocolPropertyInfo

type AttrOrigin AddressProtocolPropertyInfo = Address

type AttrLabel AddressProtocolPropertyInfo

type AttrLabel AddressProtocolPropertyInfo = "protocol"

type AttrGetType AddressProtocolPropertyInfo

type AttrGetType AddressProtocolPropertyInfo = Maybe Text

type AttrBaseTypeConstraint AddressProtocolPropertyInfo

type AttrBaseTypeConstraint AddressProtocolPropertyInfo = IsAddress

type AttrSetTypeConstraint AddressProtocolPropertyInfo

type AttrSetTypeConstraint AddressProtocolPropertyInfo = * ~ Text

type AttrAllowedOps AddressProtocolPropertyInfo

type AttrAllowedOps AddressProtocolPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag)))

addressProtocol :: AttrLabelProxy "protocol"

constructAddressProtocol :: IsAddress o => Text -> IO (GValueConstruct o)

getAddressProtocol :: (MonadIO m, IsAddress o) => o -> m (Maybe Text)

sockaddr

data AddressSockaddrPropertyInfo

Instances

AttrInfo AddressSockaddrPropertyInfo

Associated Types

type AttrAllowedOps AddressSockaddrPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint AddressSockaddrPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint AddressSockaddrPropertyInfo :: * -> Constraint

type AttrGetType AddressSockaddrPropertyInfo :: *

type AttrLabel AddressSockaddrPropertyInfo :: Symbol

type AttrOrigin AddressSockaddrPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint AddressSockaddrPropertyInfo o => Proxy * AddressSockaddrPropertyInfo -> o -> IO (AttrGetType AddressSockaddrPropertyInfo)

attrSet :: (AttrBaseTypeConstraint AddressSockaddrPropertyInfo o, AttrSetTypeConstraint AddressSockaddrPropertyInfo b) => Proxy * AddressSockaddrPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint AddressSockaddrPropertyInfo o => Proxy * AddressSockaddrPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint AddressSockaddrPropertyInfo o, AttrSetTypeConstraint AddressSockaddrPropertyInfo b) => Proxy * AddressSockaddrPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin AddressSockaddrPropertyInfo

type AttrOrigin AddressSockaddrPropertyInfo = Address

type AttrLabel AddressSockaddrPropertyInfo

type AttrLabel AddressSockaddrPropertyInfo = "sockaddr"

type AttrGetType AddressSockaddrPropertyInfo

type AttrGetType AddressSockaddrPropertyInfo = Ptr ()

type AttrBaseTypeConstraint AddressSockaddrPropertyInfo

type AttrBaseTypeConstraint AddressSockaddrPropertyInfo = IsAddress

type AttrSetTypeConstraint AddressSockaddrPropertyInfo

type AttrSetTypeConstraint AddressSockaddrPropertyInfo = * ~ Ptr ()

type AttrAllowedOps AddressSockaddrPropertyInfo

type AttrAllowedOps AddressSockaddrPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag))

addressSockaddr :: AttrLabelProxy "sockaddr"

constructAddressSockaddr :: IsAddress o => Ptr () -> IO (GValueConstruct o)

getAddressSockaddr :: (MonadIO m, IsAddress o) => o -> m (Ptr ())