module GI.Soup.Objects.Address
(
Address(..) ,
IsAddress ,
toAddress ,
noAddress ,
AddressEqualByIpMethodInfo ,
addressEqualByIp ,
AddressEqualByNameMethodInfo ,
addressEqualByName ,
AddressGetGsockaddrMethodInfo ,
addressGetGsockaddr ,
AddressGetNameMethodInfo ,
addressGetName ,
AddressGetPhysicalMethodInfo ,
addressGetPhysical ,
AddressGetPortMethodInfo ,
addressGetPort ,
AddressHashByIpMethodInfo ,
addressHashByIp ,
AddressHashByNameMethodInfo ,
addressHashByName ,
AddressIsResolvedMethodInfo ,
addressIsResolved ,
addressNew ,
addressNewAny ,
addressNewFromSockaddr ,
AddressResolveAsyncMethodInfo ,
addressResolveAsync ,
AddressResolveSyncMethodInfo ,
addressResolveSync ,
AddressFamilyPropertyInfo ,
addressFamily ,
constructAddressFamily ,
getAddressFamily ,
AddressNamePropertyInfo ,
addressName ,
constructAddressName ,
getAddressName ,
AddressPhysicalPropertyInfo ,
addressPhysical ,
getAddressPhysical ,
AddressPortPropertyInfo ,
addressPort ,
constructAddressPort ,
getAddressPort ,
AddressProtocolPropertyInfo ,
addressProtocol ,
constructAddressProtocol ,
getAddressProtocol ,
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 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 (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
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
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
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
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
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
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, *)])
foreign import ccall "soup_address_new" soup_address_new ::
CString ->
Word32 ->
IO (Ptr Address)
addressNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Word32
-> m 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'
foreign import ccall "soup_address_new_any" soup_address_new_any ::
CUInt ->
Word32 ->
IO (Ptr Address)
addressNewAny ::
(B.CallStack.HasCallStack, MonadIO m) =>
Soup.Enums.AddressFamily
-> Word32
-> m (Maybe 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
foreign import ccall "soup_address_new_from_sockaddr" soup_address_new_from_sockaddr ::
Ptr () ->
Int32 ->
IO (Ptr Address)
addressNewFromSockaddr ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Int32
-> m (Maybe 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
foreign import ccall "soup_address_equal_by_ip" soup_address_equal_by_ip ::
Ptr Address ->
Ptr Address ->
IO CInt
addressEqualByIp ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) =>
a
-> b
-> m Bool
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
foreign import ccall "soup_address_equal_by_name" soup_address_equal_by_name ::
Ptr Address ->
Ptr Address ->
IO CInt
addressEqualByName ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a, IsAddress b) =>
a
-> b
-> m Bool
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
foreign import ccall "soup_address_get_gsockaddr" soup_address_get_gsockaddr ::
Ptr Address ->
IO (Ptr Gio.SocketAddress.SocketAddress)
addressGetGsockaddr ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m Gio.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
foreign import ccall "soup_address_get_name" soup_address_get_name ::
Ptr Address ->
IO CString
addressGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m (Maybe T.Text)
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
foreign import ccall "soup_address_get_physical" soup_address_get_physical ::
Ptr Address ->
IO CString
addressGetPhysical ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m (Maybe T.Text)
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
foreign import ccall "soup_address_get_port" soup_address_get_port ::
Ptr Address ->
IO Word32
addressGetPort ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m Word32
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
foreign import ccall "soup_address_hash_by_ip" soup_address_hash_by_ip ::
Ptr Address ->
IO Word32
addressHashByIp ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m Word32
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
foreign import ccall "soup_address_hash_by_name" soup_address_hash_by_name ::
Ptr Address ->
IO Word32
addressHashByName ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m Word32
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
foreign import ccall "soup_address_is_resolved" soup_address_is_resolved ::
Ptr Address ->
IO CInt
addressIsResolved ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a) =>
a
-> m Bool
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
foreign import ccall "soup_address_resolve_async" soup_address_resolve_async ::
Ptr Address ->
Ptr GLib.MainContext.MainContext ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Soup.Callbacks.C_AddressCallback ->
Ptr () ->
IO ()
addressResolveAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (GLib.MainContext.MainContext)
-> Maybe (b)
-> Soup.Callbacks.AddressCallback
-> 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
foreign import ccall "soup_address_resolve_sync" soup_address_resolve_sync ::
Ptr Address ->
Ptr Gio.Cancellable.Cancellable ->
IO Word32
addressResolveSync ::
(B.CallStack.HasCallStack, MonadIO m, IsAddress a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word32
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