{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Soup.Objects.Address
    ( 

-- * Exported types
    Address(..)                             ,
    IsAddress                               ,
    toAddress                               ,
    noAddress                               ,


 -- * Methods
-- ** equalByIp #method:equalByIp#
    AddressEqualByIpMethodInfo              ,
    addressEqualByIp                        ,


-- ** equalByName #method:equalByName#
    AddressEqualByNameMethodInfo            ,
    addressEqualByName                      ,


-- ** getGsockaddr #method:getGsockaddr#
    AddressGetGsockaddrMethodInfo           ,
    addressGetGsockaddr                     ,


-- ** getName #method:getName#
    AddressGetNameMethodInfo                ,
    addressGetName                          ,


-- ** getPhysical #method:getPhysical#
    AddressGetPhysicalMethodInfo            ,
    addressGetPhysical                      ,


-- ** getPort #method:getPort#
    AddressGetPortMethodInfo                ,
    addressGetPort                          ,


-- ** hashByIp #method:hashByIp#
    AddressHashByIpMethodInfo               ,
    addressHashByIp                         ,


-- ** hashByName #method:hashByName#
    AddressHashByNameMethodInfo             ,
    addressHashByName                       ,


-- ** isResolved #method:isResolved#
    AddressIsResolvedMethodInfo             ,
    addressIsResolved                       ,


-- ** new #method:new#
    addressNew                              ,


-- ** newAny #method:newAny#
    addressNewAny                           ,


-- ** newFromSockaddr #method:newFromSockaddr#
    addressNewFromSockaddr                  ,


-- ** resolveAsync #method:resolveAsync#
    AddressResolveAsyncMethodInfo           ,
    addressResolveAsync                     ,


-- ** resolveSync #method:resolveSync#
    AddressResolveSyncMethodInfo            ,
    addressResolveSync                      ,




 -- * Properties
-- ** family #attr:family#
    AddressFamilyPropertyInfo               ,
    addressFamily                           ,
    constructAddressFamily                  ,
    getAddressFamily                        ,


-- ** name #attr:name#
    AddressNamePropertyInfo                 ,
    addressName                             ,
    constructAddressName                    ,
    getAddressName                          ,


-- ** physical #attr:physical#
    AddressPhysicalPropertyInfo             ,
    addressPhysical                         ,
    getAddressPhysical                      ,


-- ** port #attr:port#
    AddressPortPropertyInfo                 ,
    addressPort                             ,
    constructAddressPort                    ,
    getAddressPort                          ,


-- ** protocol #attr:protocol#
    AddressProtocolPropertyInfo             ,
    addressProtocol                         ,
    constructAddressProtocol                ,
    getAddressProtocol                      ,


-- ** sockaddr #attr:sockaddr#
    AddressSockaddrPropertyInfo             ,
    addressSockaddr                         ,
    constructAddressSockaddr                ,
    getAddressSockaddr                      ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GLib.Structs.MainContext as GLib.MainContext
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums

newtype Address = Address (ManagedPtr Address)
foreign import ccall "soup_address_get_type"
    c_soup_address_get_type :: IO GType

instance GObject Address where
    gobjectType _ = c_soup_address_get_type
    

class GObject o => IsAddress o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Address a) =>
    IsAddress a
#endif
instance IsAddress Address
instance GObject.Object.IsObject Address
instance Gio.SocketConnectable.IsSocketConnectable Address

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

noAddress :: Maybe Address
noAddress = Nothing

type family ResolveAddressMethod (t :: Symbol) (o :: *) :: * where
    ResolveAddressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAddressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAddressMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo
    ResolveAddressMethod "equalByIp" o = AddressEqualByIpMethodInfo
    ResolveAddressMethod "equalByName" o = AddressEqualByNameMethodInfo
    ResolveAddressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAddressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAddressMethod "hashByIp" o = AddressHashByIpMethodInfo
    ResolveAddressMethod "hashByName" o = AddressHashByNameMethodInfo
    ResolveAddressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAddressMethod "isResolved" o = AddressIsResolvedMethodInfo
    ResolveAddressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAddressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAddressMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo
    ResolveAddressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAddressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAddressMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAddressMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAddressMethod "resolveAsync" o = AddressResolveAsyncMethodInfo
    ResolveAddressMethod "resolveSync" o = AddressResolveSyncMethodInfo
    ResolveAddressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAddressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAddressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAddressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAddressMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo
    ResolveAddressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAddressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAddressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAddressMethod "getGsockaddr" o = AddressGetGsockaddrMethodInfo
    ResolveAddressMethod "getName" o = AddressGetNameMethodInfo
    ResolveAddressMethod "getPhysical" o = AddressGetPhysicalMethodInfo
    ResolveAddressMethod "getPort" o = AddressGetPortMethodInfo
    ResolveAddressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAddressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAddressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAddressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAddressMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAddressMethod t Address, O.MethodInfo info Address p) => O.IsLabelProxy t (Address -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAddressMethod t Address, O.MethodInfo info Address p) => O.IsLabel t (Address -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "family"
   -- Type: TInterface (Name {namespace = "Soup", name = "AddressFamily"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getAddressFamily :: (MonadIO m, IsAddress o) => o -> m Soup.Enums.AddressFamily
getAddressFamily obj = liftIO $ getObjectPropertyEnum obj "family"

constructAddressFamily :: (IsAddress o) => Soup.Enums.AddressFamily -> IO (GValueConstruct o)
constructAddressFamily val = constructObjectPropertyEnum "family" val

data AddressFamilyPropertyInfo
instance AttrInfo AddressFamilyPropertyInfo where
    type AttrAllowedOps AddressFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AddressFamilyPropertyInfo = (~) Soup.Enums.AddressFamily
    type AttrBaseTypeConstraint AddressFamilyPropertyInfo = IsAddress
    type AttrGetType AddressFamilyPropertyInfo = Soup.Enums.AddressFamily
    type AttrLabel AddressFamilyPropertyInfo = "family"
    type AttrOrigin AddressFamilyPropertyInfo = Address
    attrGet _ = getAddressFamily
    attrSet _ = undefined
    attrConstruct _ = constructAddressFamily
    attrClear _ = undefined

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

getAddressName :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text)
getAddressName obj = liftIO $ getObjectPropertyString obj "name"

constructAddressName :: (IsAddress o) => T.Text -> IO (GValueConstruct o)
constructAddressName val = constructObjectPropertyString "name" (Just val)

data AddressNamePropertyInfo
instance AttrInfo AddressNamePropertyInfo where
    type AttrAllowedOps AddressNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AddressNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint AddressNamePropertyInfo = IsAddress
    type AttrGetType AddressNamePropertyInfo = (Maybe T.Text)
    type AttrLabel AddressNamePropertyInfo = "name"
    type AttrOrigin AddressNamePropertyInfo = Address
    attrGet _ = getAddressName
    attrSet _ = undefined
    attrConstruct _ = constructAddressName
    attrClear _ = undefined

-- VVV Prop "physical"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

getAddressPhysical :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text)
getAddressPhysical obj = liftIO $ getObjectPropertyString obj "physical"

data AddressPhysicalPropertyInfo
instance AttrInfo AddressPhysicalPropertyInfo where
    type AttrAllowedOps AddressPhysicalPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AddressPhysicalPropertyInfo = (~) ()
    type AttrBaseTypeConstraint AddressPhysicalPropertyInfo = IsAddress
    type AttrGetType AddressPhysicalPropertyInfo = (Maybe T.Text)
    type AttrLabel AddressPhysicalPropertyInfo = "physical"
    type AttrOrigin AddressPhysicalPropertyInfo = Address
    attrGet _ = getAddressPhysical
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "port"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getAddressPort :: (MonadIO m, IsAddress o) => o -> m Int32
getAddressPort obj = liftIO $ getObjectPropertyInt32 obj "port"

constructAddressPort :: (IsAddress o) => Int32 -> IO (GValueConstruct o)
constructAddressPort val = constructObjectPropertyInt32 "port" val

data AddressPortPropertyInfo
instance AttrInfo AddressPortPropertyInfo where
    type AttrAllowedOps AddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AddressPortPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint AddressPortPropertyInfo = IsAddress
    type AttrGetType AddressPortPropertyInfo = Int32
    type AttrLabel AddressPortPropertyInfo = "port"
    type AttrOrigin AddressPortPropertyInfo = Address
    attrGet _ = getAddressPort
    attrSet _ = undefined
    attrConstruct _ = constructAddressPort
    attrClear _ = undefined

-- VVV Prop "protocol"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getAddressProtocol :: (MonadIO m, IsAddress o) => o -> m (Maybe T.Text)
getAddressProtocol obj = liftIO $ getObjectPropertyString obj "protocol"

constructAddressProtocol :: (IsAddress o) => T.Text -> IO (GValueConstruct o)
constructAddressProtocol val = constructObjectPropertyString "protocol" (Just val)

data AddressProtocolPropertyInfo
instance AttrInfo AddressProtocolPropertyInfo where
    type AttrAllowedOps AddressProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AddressProtocolPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint AddressProtocolPropertyInfo = IsAddress
    type AttrGetType AddressProtocolPropertyInfo = (Maybe T.Text)
    type AttrLabel AddressProtocolPropertyInfo = "protocol"
    type AttrOrigin AddressProtocolPropertyInfo = Address
    attrGet _ = getAddressProtocol
    attrSet _ = undefined
    attrConstruct _ = constructAddressProtocol
    attrClear _ = undefined

-- VVV Prop "sockaddr"
   -- Type: TBasicType TPtr
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getAddressSockaddr :: (MonadIO m, IsAddress o) => o -> m (Ptr ())
getAddressSockaddr obj = liftIO $ getObjectPropertyPtr obj "sockaddr"

constructAddressSockaddr :: (IsAddress o) => Ptr () -> IO (GValueConstruct o)
constructAddressSockaddr val = constructObjectPropertyPtr "sockaddr" val

data AddressSockaddrPropertyInfo
instance AttrInfo AddressSockaddrPropertyInfo where
    type AttrAllowedOps AddressSockaddrPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AddressSockaddrPropertyInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint AddressSockaddrPropertyInfo = IsAddress
    type AttrGetType AddressSockaddrPropertyInfo = (Ptr ())
    type AttrLabel AddressSockaddrPropertyInfo = "sockaddr"
    type AttrOrigin AddressSockaddrPropertyInfo = Address
    attrGet _ = getAddressSockaddr
    attrSet _ = undefined
    attrConstruct _ = constructAddressSockaddr
    attrClear _ = undefined

instance O.HasAttributeList Address
type instance O.AttributeList Address = AddressAttributeList
type AddressAttributeList = ('[ '("family", AddressFamilyPropertyInfo), '("name", AddressNamePropertyInfo), '("physical", AddressPhysicalPropertyInfo), '("port", AddressPortPropertyInfo), '("protocol", AddressProtocolPropertyInfo), '("sockaddr", AddressSockaddrPropertyInfo)] :: [(Symbol, *)])

addressFamily :: AttrLabelProxy "family"
addressFamily = AttrLabelProxy

addressName :: AttrLabelProxy "name"
addressName = AttrLabelProxy

addressPhysical :: AttrLabelProxy "physical"
addressPhysical = AttrLabelProxy

addressPort :: AttrLabelProxy "port"
addressPort = AttrLabelProxy

addressProtocol :: AttrLabelProxy "protocol"
addressProtocol = AttrLabelProxy

addressSockaddr :: AttrLabelProxy "sockaddr"
addressSockaddr = AttrLabelProxy

type instance O.SignalList Address = AddressSignalList
type AddressSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method Address::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a hostname or physical address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a port number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_new" soup_address_new :: 
    CString ->                              -- name : TBasicType TUTF8
    Word32 ->                               -- port : TBasicType TUInt
    IO (Ptr Address)

{- |
Creates a 'GI.Soup.Objects.Address.Address' from /@name@/ and /@port@/. The 'GI.Soup.Objects.Address.Address'\'s IP
address may not be available right away; the caller can call
'GI.Soup.Objects.Address.addressResolveAsync' or 'GI.Soup.Objects.Address.addressResolveSync' to
force a DNS resolution.
-}
addressNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: a hostname or physical address -}
    -> Word32
    {- ^ /@port@/: a port number -}
    -> m Address
    {- ^ __Returns:__ a 'GI.Soup.Objects.Address.Address' -}
addressNew name port = liftIO $ do
    name' <- textToCString name
    result <- soup_address_new name' port
    checkUnexpectedReturnNULL "addressNew" result
    result' <- (wrapObject Address) result
    freeMem name'
    return result'

-- method Address::new_any
-- method type : Constructor
-- Args : [Arg {argCName = "family", argType = TInterface (Name {namespace = "Soup", name = "AddressFamily"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the address family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the port number (usually %SOUP_ADDRESS_ANY_PORT)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_new_any" soup_address_new_any :: 
    CUInt ->                                -- family : TInterface (Name {namespace = "Soup", name = "AddressFamily"})
    Word32 ->                               -- port : TBasicType TUInt
    IO (Ptr Address)

{- |
Returns a 'GI.Soup.Objects.Address.Address' corresponding to the \"any\" address
for /@family@/ (or 'Nothing' if /@family@/ isn\'t supported), suitable for
using as a listening 'GI.Soup.Objects.Socket.Socket'.
-}
addressNewAny ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Soup.Enums.AddressFamily
    {- ^ /@family@/: the address family -}
    -> Word32
    {- ^ /@port@/: the port number (usually 'GI.Soup.Constants.ADDRESS_ANY_PORT') -}
    -> m (Maybe Address)
    {- ^ __Returns:__ the new 'GI.Soup.Objects.Address.Address' -}
addressNewAny family port = liftIO $ do
    let family' = (fromIntegral . fromEnum) family
    result <- soup_address_new_any family' port
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Address) result'
        return result''
    return maybeResult

-- method Address::new_from_sockaddr
-- method type : Constructor
-- Args : [Arg {argCName = "sa", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a pointer to a sockaddr", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of @sa", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Address"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_new_from_sockaddr" soup_address_new_from_sockaddr :: 
    Ptr () ->                               -- sa : TBasicType TPtr
    Int32 ->                                -- len : TBasicType TInt
    IO (Ptr Address)

{- |
Returns a 'GI.Soup.Objects.Address.Address' equivalent to /@sa@/ (or 'Nothing' if /@sa@/\'s
address family isn\'t supported)
-}
addressNewFromSockaddr ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    {- ^ /@sa@/: a pointer to a sockaddr -}
    -> Int32
    {- ^ /@len@/: size of /@sa@/ -}
    -> m (Maybe Address)
    {- ^ __Returns:__ the new 'GI.Soup.Objects.Address.Address' -}
addressNewFromSockaddr sa len = liftIO $ do
    result <- soup_address_new_from_sockaddr sa len
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Address) result'
        return result''
    return maybeResult

-- method Address::equal_by_ip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr1", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress with a resolved IP\n  address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "addr2", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #SoupAddress with a resolved\n  IP address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_equal_by_ip" soup_address_equal_by_ip :: 
    Ptr Address ->                          -- addr1 : TInterface (Name {namespace = "Soup", name = "Address"})
    Ptr Address ->                          -- addr2 : TInterface (Name {namespace = "Soup", name = "Address"})
    IO CInt

{- |
Tests if /@addr1@/ and /@addr2@/ have the same IP address. This method
can be used with 'GI.Soup.Objects.Address.addressHashByIp' to create a
'GI.GLib.Structs.HashTable.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 'GI.Soup.Objects.Address.addressEqualByName', which compares by name
rather than by IP address.

@since 2.26
-}
addressEqualByIp ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) =>
    a
    {- ^ /@addr1@/: a 'GI.Soup.Objects.Address.Address' with a resolved IP
  address -}
    -> b
    {- ^ /@addr2@/: another 'GI.Soup.Objects.Address.Address' with a resolved
  IP address -}
    -> m Bool
    {- ^ __Returns:__ whether or not /@addr1@/ and /@addr2@/ have the same IP
address. -}
addressEqualByIp addr1 addr2 = liftIO $ do
    addr1' <- unsafeManagedPtrCastPtr addr1
    addr2' <- unsafeManagedPtrCastPtr addr2
    result <- soup_address_equal_by_ip addr1' addr2'
    let result' = (/= 0) result
    touchManagedPtr addr1
    touchManagedPtr addr2
    return result'

data AddressEqualByIpMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => O.MethodInfo AddressEqualByIpMethodInfo a signature where
    overloadedMethod _ = addressEqualByIp

-- method Address::equal_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr1", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress with a resolved name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "addr2", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #SoupAddress with a resolved\n  name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_equal_by_name" soup_address_equal_by_name :: 
    Ptr Address ->                          -- addr1 : TInterface (Name {namespace = "Soup", name = "Address"})
    Ptr Address ->                          -- addr2 : TInterface (Name {namespace = "Soup", name = "Address"})
    IO CInt

{- |
Tests if /@addr1@/ and /@addr2@/ have the same \"name\". This method can be
used with 'GI.Soup.Objects.Address.addressHashByName' to create a 'GI.GLib.Structs.HashTable.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 'GI.Soup.Objects.Address.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 'GI.Soup.Objects.Address.addressEqualByIp', which compares by IP address
rather than by name.

@since 2.26
-}
addressEqualByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) =>
    a
    {- ^ /@addr1@/: a 'GI.Soup.Objects.Address.Address' with a resolved name -}
    -> b
    {- ^ /@addr2@/: another 'GI.Soup.Objects.Address.Address' with a resolved
  name -}
    -> m Bool
    {- ^ __Returns:__ whether or not /@addr1@/ and /@addr2@/ have the same name -}
addressEqualByName addr1 addr2 = liftIO $ do
    addr1' <- unsafeManagedPtrCastPtr addr1
    addr2' <- unsafeManagedPtrCastPtr addr2
    result <- soup_address_equal_by_name addr1' addr2'
    let result' = (/= 0) result
    touchManagedPtr addr1
    touchManagedPtr addr2
    return result'

data AddressEqualByNameMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsAddress a, IsAddress b) => O.MethodInfo AddressEqualByNameMethodInfo a signature where
    overloadedMethod _ = addressEqualByName

-- method Address::get_gsockaddr
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketAddress"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_get_gsockaddr" soup_address_get_gsockaddr :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO (Ptr Gio.SocketAddress.SocketAddress)

{- |
Creates a new 'GI.Gio.Objects.SocketAddress.SocketAddress' corresponding to /@addr@/ (which is assumed
to only have one socket address associated with it).

@since 2.32
-}
addressGetGsockaddr ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m Gio.SocketAddress.SocketAddress
    {- ^ __Returns:__ a new 'GI.Gio.Objects.SocketAddress.SocketAddress' -}
addressGetGsockaddr addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_get_gsockaddr addr'
    checkUnexpectedReturnNULL "addressGetGsockaddr" result
    result' <- (wrapObject Gio.SocketAddress.SocketAddress) result
    touchManagedPtr addr
    return result'

data AddressGetGsockaddrMethodInfo
instance (signature ~ (m Gio.SocketAddress.SocketAddress), MonadIO m, IsAddress a) => O.MethodInfo AddressGetGsockaddrMethodInfo a signature where
    overloadedMethod _ = addressGetGsockaddr

-- method Address::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_get_name" soup_address_get_name :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO CString

{- |
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
'GI.Soup.Objects.Address.addressIsResolved' to safely test whether or not an address
is resolved before fetching its name or address.
-}
addressGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the hostname, or 'Nothing' if it is not known. -}
addressGetName addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_get_name addr'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr addr
    return maybeResult

data AddressGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAddress a) => O.MethodInfo AddressGetNameMethodInfo a signature where
    overloadedMethod _ = addressGetName

-- method Address::get_physical
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_get_physical" soup_address_get_physical :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO CString

{- |
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
'GI.Soup.Objects.Address.addressIsResolved' to safely test whether or not an address
is resolved before fetching its name or address.
-}
addressGetPhysical ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the physical address, or 'Nothing' -}
addressGetPhysical addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_get_physical addr'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr addr
    return maybeResult

data AddressGetPhysicalMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAddress a) => O.MethodInfo AddressGetPhysicalMethodInfo a signature where
    overloadedMethod _ = addressGetPhysical

-- method Address::get_port
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_get_port" soup_address_get_port :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO Word32

{- |
Returns the port associated with /@addr@/.
-}
addressGetPort ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m Word32
    {- ^ __Returns:__ the port -}
addressGetPort addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_get_port addr'
    touchManagedPtr addr
    return result

data AddressGetPortMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressGetPortMethodInfo a signature where
    overloadedMethod _ = addressGetPort

-- method Address::hash_by_ip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_hash_by_ip" soup_address_hash_by_ip :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO Word32

{- |
A hash function (for 'GI.GLib.Structs.HashTable.HashTable') that corresponds to
'GI.Soup.Objects.Address.addressEqualByIp', qv

@since 2.26
-}
addressHashByIp ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m Word32
    {- ^ __Returns:__ the IP-based hash value for /@addr@/. -}
addressHashByIp addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_hash_by_ip addr'
    touchManagedPtr addr
    return result

data AddressHashByIpMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressHashByIpMethodInfo a signature where
    overloadedMethod _ = addressHashByIp

-- method Address::hash_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_hash_by_name" soup_address_hash_by_name :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO Word32

{- |
A hash function (for 'GI.GLib.Structs.HashTable.HashTable') that corresponds to
'GI.Soup.Objects.Address.addressEqualByName', qv

@since 2.26
-}
addressHashByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m Word32
    {- ^ __Returns:__ the named-based hash value for /@addr@/. -}
addressHashByName addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_hash_by_name addr'
    touchManagedPtr addr
    return result

data AddressHashByNameMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsAddress a) => O.MethodInfo AddressHashByNameMethodInfo a signature where
    overloadedMethod _ = addressHashByName

-- method Address::is_resolved
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_is_resolved" soup_address_is_resolved :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    IO CInt

{- |
Tests if /@addr@/ has already been resolved. Unlike the other
'GI.Soup.Objects.Address.Address' \"get\" methods, this is safe to call when /@addr@/ might
be being resolved in another thread.
-}
addressIsResolved ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@addr@/ has been resolved. -}
addressIsResolved addr = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    result <- soup_address_is_resolved addr'
    let result' = (/= 0) result
    touchManagedPtr addr
    return result'

data AddressIsResolvedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAddress a) => O.MethodInfo AddressIsResolvedMethodInfo a signature where
    overloadedMethod _ = addressIsResolved

-- method Address::resolve_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "async_context", argType = TInterface (Name {namespace = "GLib", name = "MainContext"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GMainContext to call @callback from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Soup", name = "AddressCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "callback to call with the result", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_resolve_async" soup_address_resolve_async :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    Ptr GLib.MainContext.MainContext ->     -- async_context : TInterface (Name {namespace = "GLib", name = "MainContext"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Soup.Callbacks.C_AddressCallback -> -- callback : TInterface (Name {namespace = "Soup", name = "AddressCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously resolves the missing half of /@addr@/ (its IP address
if it was created with 'GI.Soup.Objects.Address.addressNew', or its hostname if it
was created with 'GI.Soup.Objects.Address.addressNewFromSockaddr' or
'GI.Soup.Objects.Address.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 'GI.Soup.Enums.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 'GI.Soup.Objects.Address.addressResolveSync'.
-}
addressResolveAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> Maybe (GLib.MainContext.MainContext)
    {- ^ /@asyncContext@/: the 'GI.GLib.Structs.MainContext.MainContext' to call /@callback@/ from -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -}
    -> Soup.Callbacks.AddressCallback
    {- ^ /@callback@/: callback to call with the result -}
    -> m ()
addressResolveAsync addr asyncContext cancellable callback = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    maybeAsyncContext <- case asyncContext of
        Nothing -> return nullPtr
        Just jAsyncContext -> do
            jAsyncContext' <- unsafeManagedPtrGetPtr jAsyncContext
            return jAsyncContext'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Soup.Callbacks.C_AddressCallback))
    callback' <- Soup.Callbacks.mk_AddressCallback (Soup.Callbacks.wrap_AddressCallback (Just ptrcallback) (Soup.Callbacks.drop_closures_AddressCallback callback))
    poke ptrcallback callback'
    let userData = nullPtr
    soup_address_resolve_async addr' maybeAsyncContext maybeCancellable callback' userData
    touchManagedPtr addr
    whenJust asyncContext touchManagedPtr
    whenJust cancellable touchManagedPtr
    return ()

data AddressResolveAsyncMethodInfo
instance (signature ~ (Maybe (GLib.MainContext.MainContext) -> Maybe (b) -> Soup.Callbacks.AddressCallback -> m ()), MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => O.MethodInfo AddressResolveAsyncMethodInfo a signature where
    overloadedMethod _ = addressResolveAsync

-- method Address::resolve_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_address_resolve_sync" soup_address_resolve_sync :: 
    Ptr Address ->                          -- addr : TInterface (Name {namespace = "Soup", name = "Address"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    IO Word32

{- |
Synchronously resolves the missing half of /@addr@/, as with
'GI.Soup.Objects.Address.addressResolveAsync'.

If /@cancellable@/ is non-'Nothing', it can be used to cancel the
resolution. 'GI.Soup.Objects.Address.addressResolveSync' will then return a status
of 'GI.Soup.Enums.StatusCancelled'.

It is safe to call this more than once, even from different
threads, but it is not safe to mix calls to
'GI.Soup.Objects.Address.addressResolveSync' with calls to
'GI.Soup.Objects.Address.addressResolveAsync' on the same address.
-}
addressResolveSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@addr@/: a 'GI.Soup.Objects.Address.Address' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -}
    -> m Word32
    {- ^ __Returns:__ 'GI.Soup.Enums.StatusOk', 'GI.Soup.Enums.StatusCantResolve', or
'GI.Soup.Enums.StatusCancelled'. -}
addressResolveSync addr cancellable = liftIO $ do
    addr' <- unsafeManagedPtrCastPtr addr
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    result <- soup_address_resolve_sync addr' maybeCancellable
    touchManagedPtr addr
    whenJust cancellable touchManagedPtr
    return result

data AddressResolveSyncMethodInfo
instance (signature ~ (Maybe (b) -> m Word32), MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) => O.MethodInfo AddressResolveSyncMethodInfo a signature where
    overloadedMethod _ = addressResolveSync